diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..5a6abb8 --- /dev/null +++ b/.gitignore @@ -0,0 +1,12 @@ +build/ +*.exe +*.ilk +*.pdb +fns.txt +.vs +*.exp +*.lib +*.bin +a.out +.vscode/ +secrets.json \ No newline at end of file diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..dc3c256 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "resources/protobufs"] + path = resources/protobufs + url = https://github.com/SteamDatabase/Protobufs \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..125ba9f --- /dev/null +++ b/LICENSE @@ -0,0 +1,25 @@ +BSD 2-Clause License + +Copyright (c) 2020, Emily Hudson +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. 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 HOLDER 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. \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..af4fc9a --- /dev/null +++ b/README.md @@ -0,0 +1,14 @@ +# Vapor + +Vapor is a steamkit implementation for the V programming language. Based on the work I did for [argonx](https://github.com/emily33901/argonx), but with different goals. +Vapor intends to be the [SteamKit](https://github.com/SteamRE/SteamKit) of the V programming world. No grandeur ideas of replacing `steamclient.dll` here, just a way to interface with Steam. + +Vapor uses the components that I have been building out over time after realising that I would need to provide them myself. If you are interested in using any of them they are (in no particular order): +* Protobuf support: [protoc-v](https://github.com/emily33901/protoc-v) (and [vproto](https://github.com/emily33901/vproto)) +* RSA and AES encryption: [vtomcrypt](https://github.com/emily33901/vtomcrypt) +* TCP Networking support: [net](https://github.com/emily33901/vlang-net) +* Simple Zip compression: [zip](https://github.com/emily33901/vzip) + +Vapor is still a work in progress. + +Protobufs are currently not formatted becuase vfmt is eating module names! diff --git a/alanguage.v b/alanguage.v new file mode 100644 index 0000000..a350ee4 --- /dev/null +++ b/alanguage.v @@ -0,0 +1,777 @@ +module vapor + +#include "@VROOT/pack_helper.h" + +pub enum EUniverse { + invalid = 0 + public = 1 + beta = 2 + internal = 3 + dev = 4 + rc = 5 // obsolete - universe no longer exists + // max = 5 +} + +pub enum EChatEntryType { + invalid = 0 + chat_msg = 1 + typing = 2 + invite_game = 3 + emote = 4 + lobby_game_start = 5 + left_conversation = 6 + entered = 7 + was_kicked = 8 + was_banned = 9 + disconnected = 10 +} + +pub enum EPersonaState { + offline = 0 + online = 1 + busy = 2 + away = 3 + snooze = 4 + looking_to_trade = 5 + looking_to_play = 6 + // max = 7 +} + +pub enum EAccountType { + invalid = 0 + individual = 1 + multiseat = 2 + game_server = 3 + anon_game_server = 4 + pending = 5 + content_server = 6 + clan = 7 + chat = 8 + console_user = 9 + anon_user = 10 + max = 11 +} + +pub enum EFriendRelationship { + none_ = 0 + blocked = 1 + // pending_invitee = 2// obsolete - renamed to request_recipient + request_recipient = 2 + friend = 3 + request_initiator = 4 + // pending_inviter = 4// obsolete - renamed to request_initiator + ignored = 5 + ignored_friend = 6 + suggested_friend = 7 + max = 8 +} + +pub enum EAccountFlags { + normal_user = 0 + persona_name_set = 1 + unbannable = 2 + password_set = 4 + support = 8 + admin = 16 + supervisor = 32 + app_editor = 64 + hwidset = 128 + personal_qaset = 256 + vac_beta = 512 + debug = 1024 + disabled = 2048 + limited_user = 4096 + limited_user_force = 8192 + email_validated = 16384 + marketing_treatment = 32768 + ogginvite_opt_out = 65536 + force_password_change = 131072 + force_email_verification = 262144 + logon_extra_security = 524288 + logon_extra_security_disabled = 1048576 +} + +pub enum EClanPermission { + nobody = 0 + owner = 1 + officer = 2 + owner_and_officer = 3 + member = 4 + moderator = 8 +} + +pub enum EChatPermission { + close = 1 + invite = 2 + talk = 8 + kick = 16 + mute = 32 + set_metadata = 64 + change_permissions = 128 + ban = 256 + change_access = 512 + // everyone_not_in_clan_default = 8 + // everyone_default = 10 + // member_default = 282 + // officer_default = 282 + // owner_default = 891 + // mask = 1019 +} + +pub enum EFriendFlags { + none_ = 0 + blocked = 1 + friendship_requested = 2 + immediate = 4 + clan_member = 8 + // game_server = 16// obsolete - renamed to on_game_server + on_game_server = 16 + requesting_friendship = 128 + requesting_info = 256 + ignored = 512 + ignored_friend = 1024 + flag_all = 65535 +} + +pub enum EClientPersonaStateFlag { + status = 1 + player_name = 2 + query_port = 4 + source_id = 8 + presence = 16 + metadata = 32 + last_seen = 64 + clan_info = 128 + game_extra_info = 256 + game_data_blob = 512 + clan_tag = 1024 + facebook = 2048 +} + +pub enum EAppUsageEvent { + game_launch = 1 + game_launch_trial = 2 + media = 3 + preload_start = 4 + preload_finish = 5 + marketing_message_view = 6 + in_game_ad_viewed = 7 + game_launch_free_weekend = 8 +} + +pub enum ELicenseFlags { + none_ = 0 + renew = 0x01 + renewal_failed = 0x02 + pending = 0x04 + expired = 0x08 + cancelled_by_user = 0x10 + cancelled_by_admin = 0x20 + low_violence_content = 0x40 + imported_from_steam2 = 0x80 +} + +pub enum ELicenseType { + no_license = 0 + single_purchase = 1 + single_purchase_limited_use = 2 + recurring_charge = 3 + recurring_charge_limited_use = 4 + recurring_charge_limited_use_with_overages = 5 + recurring_option = 6 +} + +pub enum EPaymentMethod { + none_ = 0 + activation_code = 1 + credit_card = 2 + giropay = 3 + pay_pal = 4 + ideal = 5 + pay_safe_card = 6 + sofort = 7 + guest_pass = 8 + web_money = 9 + money_bookers = 10 + ali_pay = 11 + yandex = 12 + kiosk = 13 + qiwi = 14 + game_stop = 15 + hardware_promo = 16 + mo_pay = 17 + boleto_bancario = 18 + boa_compra_gold = 19 + banco_do_brasil_online = 20 + itau_online = 21 + bradesco_online = 22 + pagseguro = 23 + visa_brazil = 24 + amex_brazil = 25 + aura = 26 + hipercard = 27 + mastercard_brazil = 28 + diners_card_brazil = 29 + click_and_buy = 32 + auto_grant = 64 + wallet = 128 + valve = 129 + oemticket = 256 + split = 512 + complimentary = 1024 +} + +pub enum EIntroducerRouting { + file_share = 0 // obsolete + p2pvoice_chat = 1 + p2pnetworking = 2 +} + +pub enum EServerFlags { + none_ = 0 + active = 1 + secure = 2 + dedicated = 4 + linux = 8 + passworded = 16 + private = 32 +} + +pub enum EDenyReason { + invalid_version = 1 + generic = 2 + not_logged_on = 3 + no_license = 4 + cheater = 5 + logged_in_else_where = 6 + unknown_text = 7 + incompatible_anticheat = 8 + memory_corruption = 9 + incompatible_software = 10 + steam_connection_lost = 11 + steam_connection_error = 12 + steam_response_timed_out = 13 + steam_validation_stalled = 14 + steam_owner_left_guest_user = 15 +} + +pub enum EClanRank { + none_ = 0 + owner = 1 + officer = 2 + member = 3 + moderator = 4 +} + +pub enum EClanRelationship { + none_ = 0 + blocked = 1 + invited = 2 + member = 3 + kicked = 4 + kick_acknowledged = 5 +} + +pub enum EAuthSessionResponse { + ok = 0 + user_not_connected_to_steam = 1 + no_license_or_expired = 2 + vacbanned = 3 + logged_in_else_where = 4 + vaccheck_timed_out = 5 + auth_ticket_canceled = 6 + auth_ticket_invalid_already_used = 7 + auth_ticket_invalid = 8 +} + +pub enum EChatRoomEnterResponse { + success = 1 + doesnt_exist = 2 + not_allowed = 3 + full = 4 + error = 5 + banned = 6 + limited = 7 + clan_disabled = 8 + community_ban = 9 + member_blocked_you = 10 + you_blocked_member = 11 + no_ranking_data_lobby = 12 + no_ranking_data_user = 13 + rank_out_of_range = 14 +} + +pub enum EChatRoomType { + friend = 1 + muc = 2 + lobby = 3 +} + +pub enum EChatInfoType { + state_change = 1 + info_update = 2 + member_limit_change = 3 +} + +pub enum EChatAction { + invite_chat = 1 + kick = 2 + ban = 3 + un_ban = 4 + start_voice_speak = 5 + end_voice_speak = 6 + lock_chat = 7 + unlock_chat = 8 + close_chat = 9 + set_joinable = 10 + set_unjoinable = 11 + set_owner = 12 + set_invisible_to_friends = 13 + set_visible_to_friends = 14 + set_moderated = 15 + set_unmoderated = 16 +} + +pub enum EChatActionResult { + success = 1 + error = 2 + not_permitted = 3 + not_allowed_on_clan_member = 4 + not_allowed_on_banned_user = 5 + not_allowed_on_chat_owner = 6 + not_allowed_on_self = 7 + chat_doesnt_exist = 8 + chat_full = 9 + voice_slots_full = 10 +} + +pub enum EAppInfoSection { + unknown = 0 + all = 1 + // first = 2 + common = 2 + extended = 3 + config = 4 + stats = 5 + install = 6 + depots = 7 + vac = 8 + drm = 9 + ufs = 10 + ogg = 11 + items_unused = 12 + policies = 13 + sys_reqs = 14 + community = 15 + max = 16 +} + +pub enum EContentDownloadSourceType { + invalid = 0 + cs = 1 + cdn = 2 + lcs = 3 + // proxy = 4// obsolete - renamed to proxy_cache + proxy_cache = 4 + max = 5 +} + +pub enum EPlatformType { + unknown = 0 + win32 = 1 + win64 = 2 + linux = 3 + osx = 4 + ps3 = 5 + max = 6 +} + +pub enum EOSType { + unknown = -1 + umq = -400 + ps3 = -300 + mac_osunknown = -102 + mac_os104 = -101 + mac_os105 = -100 + mac_os1058 = -99 + mac_os106 = -95 + mac_os1063 = -94 + mac_os1064_slgu = -93 + mac_os1067 = -92 + mac_os107 = -90 + mac_os108 = -89 + mac_os109 = -88 + linux_unknown = -203 + linux22 = -202 + linux24 = -201 + linux26 = -200 + linux32 = -199 + win_unknown = 0 + win311 = 1 + win95 = 2 + win98 = 3 + win_me = 4 + win_nt = 5 + win200 = 6 + win_xp = 7 + win2003 = 8 + win_vista = 9 + win7 = 10 + win2008 = 11 + windows8 = 12 + win_max = 13 + max = 24 +} + +pub enum EServerType { + invalid = -1 + // first = 0 + shell = 0 + gm = 1 + bum = 2 + am = 3 + bs = 4 + vs = 5 + ats = 6 + cm = 7 + fbs = 8 + // fg = 9// obsolete - renamed to box_monitor + box_monitor = 9 + ss = 10 + drms = 11 + // hub_obsolete = 12// obsolete + console = 13 + // asbobsolete = 14// obsolete + pics = 14 + client = 15 + bootstrap_obsolete = 16// obsolete + dp = 17 + wg = 18 + sm = 19 + ufs = 21 + util = 23 + // dss = 24// obsolete - renamed to community + community = 24 + p2prelay_obsolete = 25// obsolete + app_information = 26 + spare = 27 + fts = 28 + epm = 29 + ps = 30 + @is = 31 + ccs = 32 + dfs = 33 + lbs = 34 + mds = 35 + cs = 36 + gc = 37 + ns = 38 + ogs = 39 + web_api = 40 + uds = 41 + mms = 42 + gms = 43 + kgs = 44 + ucm = 45 + rm = 46 + fs = 47 + econ = 48 + backpack = 49 + ugs = 50 + store = 51 + money_stats = 52 + cre = 53 + umq = 54 + workshop = 55 + brp = 56 + gch = 57 + mpas = 58 + trade = 59 + secrets = 60 + logsink = 61 + market = 62 + quest = 63 + wds = 64 + max = 65 +} + +pub enum EBillingType { + no_cost = 0 + bill_once_only = 1 + bill_monthly = 2 + proof_of_prepurchase_only = 3 + guest_pass = 4 + hardware_promo = 5 + gift = 6 + auto_grant = 7 + oemticket = 8 + num_billing_types = 9 +} + +pub enum EActivationCodeClass { + won_cdkey = 0 + valve_cdkey = 1 + doom3cdkey = 2 + dblookup = 3 + steam2010key = 4 + max = 5 + test = 2147483647 + invalid = -1 +} + +pub enum EChatMemberStateChange { + entered = 0x01 + left = 0x02 + disconnected = 0x04 + kicked = 0x08 + banned = 0x10 +} + +pub enum ERegionCode { + useast = 0x00 + uswest = 0x01 + south_america = 0x02 + europe = 0x03 + asia = 0x04 + australia = 0x05 + middle_east = 0x06 + africa = 0x07 + world = 0x8 +} + +pub enum ECurrencyCode { + invalid = 0 + usd = 1 + gbp = 2 + eur = 3 + chf = 4 + rub = 5 + pln = 6 + brl = 7 + nok = 9 + max = 10 +} + +pub enum EDepotFileFlag { + user_config = 1 + versioned_user_config = 2 + encrypted = 4 + read_only = 8 + hidden = 16 + executable = 32 + directory = 64 + custom_executable = 128 +} + +pub enum EWorkshopEnumerationType { + ranked_by_vote = 0 + recent = 1 + trending = 2 + favorite_of_friends = 3 + voted_by_friends = 4 + content_by_friends = 5 + recent_from_followed_users = 6 +} + +pub enum EPublishedFileVisibility { + public = 0 + friends_only = 1 + private = 2 +} + +pub enum EWorkshopFileAction { + played = 0 + completed = 1 +} + +pub enum EEconTradeResponse { + accepted = 0 + declined = 1 + // vac_banned_initiator = 2// obsolete - renamed to trade_banned_initiator + trade_banned_initiator = 2 + // vac_banned_target = 3// obsolete - renamed to trade_banned_target + trade_banned_target = 3 + target_already_trading = 4 + disabled = 5 + not_logged_in = 6 + cancel = 7 + too_soon = 8 + too_soon_penalty = 9 + connection_failed = 10 + initiator_already_trading = 11 + error = 12 + timeout = 13 + initiator_blocked_target = 18 + initiator_needs_verified_email = 20 + initiator_needs_steam_guard = 21 + target_account_cannot_trade = 22 + initiator_steam_guard_duration = 23 +} + +pub enum EMarketingMessageFlags { + none_ = 0 + high_priority = 1 + platform_windows = 2 + platform_mac = 4 + platform_restrictions = 6 +} + +pub enum ENewsUpdateType { + app_news = 0 + steam_ads = 1 + steam_news = 2 + cddbupdate = 3 + client_update = 4 +} + +pub enum ESystemIMType { + raw_text = 0 + invalid_card = 1 + recurring_purchase_failed = 2 + card_will_expire = 3 + subscription_expired = 4 + guest_pass_received = 5 + guest_pass_granted = 6 + gift_revoked = 7 + support_message = 8 + support_message_clear_alert = 9 + max = 10 +} + +pub enum EChatFlags { + locked = 1 + invisible_to_friends = 2 + moderated = 4 + unjoinable = 8 +} + +pub enum ERemoteStoragePlatform { + none_ = 0 + windows = 1 + osx = 2 + ps3 = 4 + reserved1 = 8 + reserved2 = 16 + all = -1 +} + +pub enum EDRMBlobDownloadType { + error = 0 + file = 1 + parts = 2 + compressed = 4 + all_mask = 7 + is_job = 8 + high_priority = 16 + add_timestamp = 32 + low_priority = 64 +} + +pub enum EDRMBlobDownloadErrorDetail { + none_ = 0 + download_failed = 1 + target_locked = 2 + open_zip = 3 + read_zip_directory = 4 + unexpected_zip_entry = 5 + unzip_full_file = 6 + unknown_blob_type = 7 + unzip_strips = 8 + unzip_merge_guid = 9 + unzip_signature = 10 + apply_strips = 11 + apply_merge_guid = 12 + apply_signature = 13 + app_id_mismatch = 14 + app_id_unexpected = 15 + applied_signature_corrupt = 16 + apply_valve_signature_header = 17 + unzip_valve_signature_header = 18 + path_manipulation_error = 19 + target_locked_base = 65536 + target_locked_max = 131071 + next_base = 131072 +} + +pub enum EClientStat { + p2pconnections_udp = 0 + p2pconnections_relay = 1 + p2pgame_connections = 2 + p2pvoice_connections = 3 + bytes_downloaded = 4 + max = 5 +} + +pub enum EClientStatAggregateMethod { + latest_only = 0 + sum = 1 + event = 2 + scalar = 3 +} + +pub enum ELeaderboardDataRequest { + global = 0 + global_around_user = 1 + friends = 2 + users = 3 +} + +pub enum ELeaderboardSortMethod { + none_ = 0 + ascending = 1 + descending = 2 +} + +pub enum ELeaderboardUploadScoreMethod { + none_ = 0 + keep_best = 1 + force_update = 2 +} + +pub enum EUdpPacketType { + invalid = 0 + challenge_req = 1 + challenge = 2 + connect = 3 + accept = 4 + disconnect = 5 + data = 6 + datagram = 7 + // max = 8 +} + +pub struct MsgChannelEncryptRequest { + protocol_version u32 + universe u32 +} + +pub struct MsgChannelEncryptResponse { +mut: + protocol_version u32 + key_size u32 +} + +pub struct MsgChannelEncryptResult { + result u32 +} + +pub struct MsgHeader { +mut: + msg u32 + target_job_id u64 + source_job_id u64 +} + +pub struct MsgBaseHeader { + msg u32 +} + +pub fn (h MsgBaseHeader) decompose() (bool, Msg) { + return msg_is_proto(h.msg), raw_msg(h.msg) +} + +pub struct MsgHdrProtobuf { +pub mut: + msg u32 + header_length int +} \ No newline at end of file diff --git a/cmlist.v b/cmlist.v new file mode 100644 index 0000000..28bdff6 --- /dev/null +++ b/cmlist.v @@ -0,0 +1,112 @@ +module vapor + +import rand + +const ( + hardcoded_cm_list = [ + '162.254.196.84:27019', + '162.254.196.84:27018', + '162.254.196.83:27017', + '162.254.196.83:27018', + '162.254.196.83:27019', + '162.254.196.67:27017', + '162.254.196.67:27019', + '162.254.196.68:27018', + '162.254.196.68:27019', + '162.254.196.67:27018', + '162.254.196.68:27017', + '162.254.196.84:27017', + '155.133.248.36:27017', + '155.133.248.38:27019', + '155.133.248.36:27018', + '155.133.248.35:27018', + '155.133.248.36:27020', + '155.133.248.34:27017', + '155.133.248.39:27023', + '155.133.248.39:27022', + '155.133.248.37:27019', + '155.133.248.39:27024', + '155.133.248.37:27017', + '155.133.248.38:27026', + '155.133.248.34:27021', + '155.133.248.35:27021', + '155.133.248.34:27018', + '155.133.248.35:27019', + '155.133.248.36:27021', + '155.133.248.35:27020', + '155.133.248.38:27020', + '155.133.248.38:27024', + '155.133.248.38:27025', + '155.133.248.39:27025', + '155.133.248.38:27023', + '155.133.248.39:27020', + '155.133.248.37:27020', + '155.133.248.34:27019', + '155.133.248.39:27027', + '155.133.248.38:27021', + '155.133.248.38:27022', + '155.133.248.39:27018', + '155.133.248.39:27019', + '155.133.248.38:27017', + '155.133.248.38:27027', + '155.133.248.39:27026', + '155.133.248.39:27021', + '155.133.248.38:27018', + '155.133.248.36:27019', + '155.133.248.37:27018', + '155.133.248.35:27017', + '155.133.248.34:27020', + '155.133.248.39:27017', + '155.133.248.37:27021', + '185.25.182.76:27018', + '185.25.182.77:27019', + '185.25.182.77:27018', + '185.25.182.76:27020', + '185.25.182.77:27021', + '185.25.182.76:27021', + '185.25.182.76:27017', + '185.25.182.77:27020', + '185.25.182.76:27019', + '185.25.182.77:27017', + '162.254.192.87:27018', + '162.254.192.87:27023', + '162.254.192.101:27021', + '162.254.192.87:27019', + '162.254.192.109:27019', + '162.254.192.71:27017', + '162.254.192.108:27019', + '162.254.192.109:27017', + '162.254.192.71:27024', + '162.254.192.87:27026', + '162.254.192.87:27022', + '162.254.192.101:27018', + '162.254.192.100:27017', + '162.254.192.87:27020', + '162.254.192.87:27017', + '162.254.192.87:27025', + '162.254.192.71:27026', + '162.254.192.87:27021', + '162.254.192.87:27027', + '162.254.192.71:27025', + '162.254.192.101:27017', + '162.254.192.71:27022', + '162.254.192.109:27020', + '162.254.192.71:27021', + '162.254.192.100:27019', + '162.254.192.100:27021', + '162.254.192.108:27018', + '162.254.192.108:27021', + '162.254.192.109:27021', + '162.254.192.109:27018', + '162.254.192.101:27019', + '162.254.192.108:27020', + '162.254.192.108:27017', + '162.254.192.100:27020', + '162.254.192.71:27019', + '162.254.192.101:27020' + ] +) + +fn hardcoded_cm() string { + return hardcoded_cm_list[rand.int_in_range(0, hardcoded_cm_list.len)] +} \ No newline at end of file diff --git a/encryptionhandler.v b/encryptionhandler.v new file mode 100644 index 0000000..45f6d4f --- /dev/null +++ b/encryptionhandler.v @@ -0,0 +1,133 @@ +module vapor + +import rand.util +import emily33901.tomcrypt +import emily33901.tomcrypt.aes +import hash.crc32 + +const ( + steam_public_key = [ + byte(0x30), 0x81, 0x9D, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, + 0x05, 0x00, 0x03, 0x81, 0x8B, 0x00, 0x30, 0x81, 0x87, 0x02, 0x81, 0x81, 0x00, 0xDF, 0xEC, 0x1A, + 0xD6, 0x2C, 0x10, 0x66, 0x2C, 0x17, 0x35, 0x3A, 0x14, 0xB0, 0x7C, 0x59, 0x11, 0x7F, 0x9D, 0xD3, + 0xD8, 0x2B, 0x7A, 0xE3, 0xE0, 0x15, 0xCD, 0x19, 0x1E, 0x46, 0xE8, 0x7B, 0x87, 0x74, 0xA2, 0x18, + 0x46, 0x31, 0xA9, 0x03, 0x14, 0x79, 0x82, 0x8E, 0xE9, 0x45, 0xA2, 0x49, 0x12, 0xA9, 0x23, 0x68, + 0x73, 0x89, 0xCF, 0x69, 0xA1, 0xB1, 0x61, 0x46, 0xBD, 0xC1, 0xBE, 0xBF, 0xD6, 0x01, 0x1B, 0xD8, + 0x81, 0xD4, 0xDC, 0x90, 0xFB, 0xFE, 0x4F, 0x52, 0x73, 0x66, 0xCB, 0x95, 0x70, 0xD7, 0xC5, 0x8E, + 0xBA, 0x1C, 0x7A, 0x33, 0x75, 0xA1, 0x62, 0x34, 0x46, 0xBB, 0x60, 0xB7, 0x80, 0x68, 0xFA, 0x13, + 0xA7, 0x7A, 0x8A, 0x37, 0x4B, 0x9E, 0xC6, 0xF4, 0x5D, 0x5F, 0x3A, 0x99, 0xF9, 0x9E, 0xC4, 0x3A, + 0xE9, 0x63, 0xA2, 0xBB, 0x88, 0x19, 0x28, 0xE0, 0xE7, 0x14, 0xC0, 0x42, 0x89, 0x02, 0x01, 0x11, + ] +) + +// EncryptionHandler is a middleware for packets +// that are encrypted and decrypted before processing / sending +struct EncryptionHandler { +mut: + s & SteamClient + session_key []byte + +pub mut: + encrypted bool +} + +fn generate_iv() []byte { + return array {data: util.time_seed_array(4).data, len: 16, element_size: 1, cap: 16} +} + +pub fn (mut e EncryptionHandler) initialise(mut s SteamClient) ? { + e.s = s + temp := util.time_seed_array(8) + e.session_key = array{data:temp.data, len:32, cap:32, element_size:1} +} + +pub fn (mut e EncryptionHandler) decrypt_packet(p Packet) ?Packet { + if !e.encrypted { + return p + } + + mut iv := []byte{len: 16} + + // free the old packet body and the iv when we are finished with them + defer { p.body.free() } + defer { iv.free() } + + aes.ecb_decrypt_into(e.session_key, p.body[..16], mut iv) + mut output := []byte{len:p.body.len-16} + + aes.cbc_decrypt_into(e.session_key, iv, p.body[16..], mut &output) + + return Packet { + header: { + size: output.len, + magic: p.header.magic + } + body: output + } +} + +pub fn (mut e EncryptionHandler) encrypt_packet(p Packet) ?Packet { + if !e.encrypted { + return p + } + + output_size := 16 + ((p.body.len / 16) + 1) * 16 + + mut output := []byte{ len:output_size } + mut @in := p.body + + mut iv := generate_iv() + + // free the old packet body and the iv when we are finished with them + defer { p.body.free() } + defer { iv.free() } + + aes.ecb_encrypt_into(e.session_key, iv, mut output[..16]) + aes.cbc_encrypt_into(e.session_key, iv, mut @in, mut output[16..]) + + return Packet { + header: { + size: output_size + } + body: output + } +} + +pub fn (mut e EncryptionHandler) handle_msg(msg Message) ? { + match msg.msg { + .channel_encrypt_request { + // 8 for header + // 128 for key + // 4 for crc32 + mut response := []byte{ len: 8+128+4+4, init: 0 } + mut res_base := &MsgChannelEncryptResponse(response.data) + res_base.protocol_version = 1 + res_base.key_size = 128 + + rsa := tomcrypt.load_rsa_key(steam_public_key) + rsa.sha1_encrypt_key_into(e.session_key, mut response[8..8+128]) + unsafe { + mut sum := &u32(response[128+8..].data) + *sum = crc32.sum(response[8..8+128]) + } + + e.s.write_non_protobuf_message(Message { + .channel_encrypt_response + msg.source + msg.target + response + })? + } + .channel_encrypt_result { + m := &MsgChannelEncryptResult(msg.body.data) + println('Channel encrypt result: $m.result') + + if m.result == 1 { + e.encrypted = true + } + } + else {} + } + return none +} + diff --git a/msg.v b/msg.v new file mode 100644 index 0000000..1d1dbb3 --- /dev/null +++ b/msg.v @@ -0,0 +1,2036 @@ +module vapor + +enum Msg +{ + invalid = 0 + multi = 1 + protobuf_wrapped = 2 + + // base_general = 100 + generic_reply = 100 + dest_job_failed = 113 + alert = 115 + scid_request = 120 + scid_response = 121 + job_heartbeat = 123 + hub_connect = 124 + subscribe = 126 + route_message = 127 + // remote_sys_id = 128 // removed + // am_create_account_response = 129 // obsolete + wg_request = 130 + wg_response = 131 + keep_alive = 132 + web_api_job_request = 133 + web_api_job_response = 134 + client_session_start = 135 + client_session_end = 136 + // client_session_update_auth_ticket = 137 // removed "renamed to ClientSessionUpdate" + client_session_update = 137 + // stats_deprecated = 138 // removed + ping = 139 + ping_response = 140 + stats = 141 + request_full_stats_block = 142 + load_dbo_cache_item = 143 + load_dbo_cache_item_response = 144 + invalidate_dbo_cache_items = 145 + service_method = 146 + service_method_response = 147 + client_package_versions = 148 + timestamp_request = 149 + timestamp_response = 150 + service_method_call_from_client = 151 + service_method_send_to_client = 152 + + // base_shell = 200 + assign_sys_id = 200 + exit = 201 + dir_request = 202 + dir_response = 203 + zip_request = 204 + zip_response = 205 + update_record_response = 215 + update_credit_card_request = 221 + update_user_ban_response = 225 + prepare_to_exit = 226 + content_description_update = 227 + test_reset_server = 228 + universe_changed = 229 + shell_config_info_update = 230 + request_windows_event_log_entries = 233 + provide_windows_event_log_entries = 234 + shell_search_logs = 235 + shell_search_logs_response = 236 + shell_check_windows_updates = 237 + shell_check_windows_updates_response = 238 + // shell_flush_user_license_cache = 239 // removed + test_flush_delayed_sql = 240 + test_flush_delayed_sql_response = 241 + ensure_execute_scheduled_task_test = 242 + ensure_execute_scheduled_task_response_test = 243 + update_scheduled_task_enable_state_test = 244 + update_scheduled_task_enable_state_response_test = 245 + content_description_delta_update = 246 + + // base_gm = 300 + heartbeat = 300 + shell_failed = 301 + exit_shells = 307 + exit_shell = 308 + graceful_exit_shell = 309 + // notify_watchdog = 314 // removed "Value changed to 10000" + license_processing_complete = 316 + set_test_flag = 317 + queued_emails_complete = 318 + gm_report_php_error = 319 + gmdrm_sync = 320 + physical_box_inventory = 321 + update_config_file = 322 + test_init_db = 323 + gm_write_config_to_sql = 324 + gm_load_activation_codes = 325 + gm_queue_for_fbs = 326 + gm_schema_conversion_results = 327 + // gm_schema_conversion_results_response = 328 // removed + gm_write_shell_failure_to_sql = 329 + gm_write_stats_to_sos = 330 + gm_get_service_method_routing = 331 + gm_get_service_method_routing_response = 332 + gm_convert_user_wallets = 333 + gm_test_next_build_schema_conversion = 334 + gm_test_next_build_schema_conversion_response = 335 + expect_shell_restart = 336 + hot_fix_progress = 337 + + // base_ais = 400 + // ais_refresh_content_description = 401 // removed + ais_request_content_description = 402 + ais_update_app_info = 403 + // ais_update_package_info = 404 // removed "renamed to AISUpdatePackageCosts" + // ais_update_package_costs = 404 // obsolete + ais_get_package_change_number = 405 + ais_get_package_change_number_response = 406 + // ais_app_info_table_changed = 407 // removed + // ais_update_package_costs_response = 408 // obsolete + // ais_create_marketing_message = 409 // obsolete + // ais_create_marketing_message_response = 410 // obsolete + // ais_get_marketing_message = 411 // obsolete + // ais_get_marketing_message_response = 412 // obsolete + // ais_update_marketing_message = 413 // obsolete + // ais_update_marketing_message_response = 414 // obsolete + // ais_request_marketing_message_update = 415 // obsolete + // ais_delete_marketing_message = 416 // obsolete + // ais_get_marketing_treatments = 419 // removed + // ais_get_marketing_treatments_response = 420 // removed + // ais_request_marketing_treatment_update = 421 // removed + // ais_test_add_package = 422 // removed + ai_get_app_gc_flags = 423 + ai_get_app_gc_flags_response = 424 + ai_get_app_list = 425 + ai_get_app_list_response = 426 + // ai_get_app_info = 427 // removed + // ai_get_app_info_response = 428 // removed + ais_get_coupon_definition = 429 + ais_get_coupon_definition_response = 430 + ais_update_slave_content_description = 431 + ais_update_slave_content_description_response = 432 + ais_test_enable_gc = 433 + + // base_am = 500 + am_update_user_ban_request = 504 + am_add_license = 505 + // am_begin_processing_licenses = 507 // removed + am_send_system_im_to_user = 508 + am_extend_license = 509 + am_add_minutes_to_license = 510 + am_cancel_license = 511 + am_init_purchase = 512 + am_purchase_response = 513 + am_get_final_price = 514 + am_get_final_price_response = 515 + am_get_legacy_game_key = 516 + am_get_legacy_game_key_response = 517 + am_find_hung_transactions = 518 + am_set_account_trusted_request = 519 + // am_complete_purchase = 521 // obsolete + am_cancel_purchase = 522 + am_new_challenge = 523 + am_load_oem_tickets = 524 + am_fix_pending_purchase = 525 + am_fix_pending_purchase_response = 526 + am_is_user_banned = 527 + am_register_key = 528 + am_load_activation_codes = 529 + am_load_activation_codes_response = 530 + am_lookup_key_response = 531 + am_lookup_key = 532 + am_chat_cleanup = 533 + am_clan_cleanup = 534 + am_fix_pending_refund = 535 + am_reverse_chargeback = 536 + am_reverse_chargeback_response = 537 + am_clan_cleanup_list = 538 + am_get_licenses = 539 + am_get_licenses_response = 540 + am_send_cart_repurchase = 541 + am_send_cart_repurchase_response = 542 + allow_user_to_play_query = 550 + allow_user_to_play_response = 551 + am_verfiy_user = 552 + am_client_not_playing = 553 + // client_request_friendship = 554 // obsolete "Renamed to AMClientRequestFriendship" + am_client_request_friendship = 554 + am_relay_publish_status = 555 + // am_reset_community_content = 556 // removed + // am_prime_persona_state_cache = 557 // removed + // am_allow_user_content_query = 558 // removed + // am_allow_user_content_response = 559 // removed + am_init_purchase_response = 560 + am_revoke_purchase_response = 561 + // am_lock_profile = 562 // removed + am_refresh_guest_passes = 563 + // am_invite_user_to_clan = 564 // obsolete + // am_acknowledge_clan_invite = 565 // obsolete + am_grant_guest_passes = 566 + am_clan_data_updated = 567 + am_reload_account = 568 + am_client_chat_msg_relay = 569 + am_chat_multi = 570 + am_client_chat_invite_relay = 571 + am_chat_invite = 572 + am_client_join_chat_relay = 573 + am_client_chat_member_info_relay = 574 + am_publish_chat_member_info = 575 + am_client_accept_friend_invite = 576 + am_chat_enter = 577 + am_client_publish_removal_from_source = 578 + am_chat_action_result = 579 + am_find_accounts = 580 + am_find_accounts_response = 581 + am_request_account_data = 582 + am_request_account_data_response = 583 + am_set_account_flags = 584 + am_create_clan = 586 + am_create_clan_response = 587 + am_get_clan_details = 588 + am_get_clan_details_response = 589 + am_set_persona_name = 590 + am_set_avatar = 591 + am_authenticate_user = 592 + am_authenticate_user_response = 593 + // am_get_account_friends_count = 594 // removed + // am_get_account_friends_count_response = 595 // removed + amp2_p_introducer_message = 596 + client_chat_action = 597 + am_client_chat_action_relay = 598 + + // base_vs = 600 + req_challenge = 600 + vac_response = 601 + req_challenge_test = 602 + vs_mark_cheat = 604 + vs_add_cheat = 605 + vs_purge_code_mod_db = 606 + vs_get_challenge_results = 607 + vs_challenge_result_text = 608 + vs_report_lingerer = 609 + vs_request_managed_challenge = 610 + vs_load_db_finished = 611 + + // base_drms = 625 + drm_build_blob_request = 628 + drm_build_blob_response = 629 + drm_resolve_guid_request = 630 + drm_resolve_guid_response = 631 + drm_variability_report = 633 + drm_variability_report_response = 634 + drm_stability_report = 635 + drm_stability_report_response = 636 + drm_details_report_request = 637 + drm_details_report_response = 638 + drm_process_file = 639 + drm_admin_update = 640 + drm_admin_update_response = 641 + drm_sync = 642 + drm_sync_response = 643 + drm_process_file_response = 644 + drm_empty_guid_cache = 645 + drm_empty_guid_cache_response = 646 + + // base_cs = 650 + // cs_user_content_request = 652 // removed + + // base_client = 700 + // client_log_on_deprecated = 701 // removed + // client_anon_log_on_deprecated = 702 // removed + client_heart_beat = 703 + client_vac_response = 704 + // client_games_played_obsolete = 705 // removed + client_log_off = 706 + client_no_udp_connectivity = 707 + // client_inform_of_create_account = 708 // obsolete + // client_ack_vac_ban = 709 // removed + client_connection_stats = 710 + // client_init_purchase = 711 // removed + client_ping_response = 712 + client_remove_friend = 714 + client_games_played_no_data_blob = 715 + client_change_status = 716 + client_vac_status_response = 717 + client_friend_msg = 718 + // client_game_connect_obsolete = 719 // removed + // client_games_played2_obsolete = 720 // removed + // client_game_ended_obsolete = 721 // removed + // client_get_final_price = 722 // removed + client_system_im = 726 + client_system_im_ack = 727 + client_get_licenses = 728 + // client_cancel_license = 729 // removed + client_get_legacy_game_key = 730 + // client_content_server_log_on_deprecated = 731 // removed + client_ack_vac_ban2 = 732 + // client_ack_message_by_gid = 735 // removed + client_get_purchase_receipts = 736 + // client_ack_purchase_receipt = 737 // removed + // client_games_played3_obsolete = 738 // removed + // client_send_guest_pass = 739 // removed + client_ack_guest_pass = 740 + client_redeem_guest_pass = 741 + client_games_played = 742 + client_register_key = 743 + client_invite_user_to_clan = 744 + client_acknowledge_clan_invite = 745 + client_purchase_with_machine_id = 746 + client_app_usage_event = 747 + // client_get_gift_target_list = 748 // removed + // client_get_gift_target_list_response = 749 // removed + client_log_on_response = 751 + // client_vac_challenge = 753 // removed + client_set_heartbeat_rate = 755 + // client_not_logged_on_deprecated = 756 // removed + client_logged_off = 757 + gs_approve = 758 + gs_deny = 759 + gs_kick = 760 + client_create_acct_response = 761 + client_purchase_response = 763 + client_ping = 764 + client_nop = 765 + client_persona_state = 766 + client_friends_list = 767 + client_account_info = 768 + // client_vac_status_query = 770 // removed + client_news_update = 771 + client_game_connect_deny = 773 + gs_status_reply = 774 + // client_get_final_price_response = 775 // removed + client_game_connect_tokens = 779 + client_license_list = 780 + // client_cancel_license_response = 781 // removed + client_vac_ban_status = 782 + client_cm_list = 783 + client_encrypt_pct = 784 + client_get_legacy_game_key_response = 785 + // client_favorites_list = 786 // removed + // cs_user_content_approve = 787 // removed + // cs_user_content_deny = 788 // removed + // client_init_purchase_response = 789 // removed + client_add_friend = 791 + client_add_friend_response = 792 + // client_invite_friend = 793 // removed + // client_invite_friend_response = 794 // removed + // client_send_guest_pass_response = 795 // removed + client_ack_guest_pass_response = 796 + client_redeem_guest_pass_response = 797 + client_update_guest_passes_list = 798 + client_chat_msg = 799 + client_chat_invite = 800 + client_join_chat = 801 + client_chat_member_info = 802 + // client_log_on_with_credentials_deprecated = 803 // removed + client_password_change_response = 805 + client_chat_enter = 807 + client_friend_removed_from_source = 808 + client_create_chat = 809 + client_create_chat_response = 810 + // client_update_chat_metadata = 811 // removed + client_p2_p_introducer_message = 813 + client_chat_action_result = 814 + client_request_friend_data = 815 + client_get_user_stats = 818 + client_get_user_stats_response = 819 + client_store_user_stats = 820 + client_store_user_stats_response = 821 + client_clan_state = 822 + client_service_module = 830 + client_service_call = 831 + client_service_call_response = 832 + // client_package_info_request = 833 // removed + // client_package_info_response = 834 // removed + client_nat_traversal_stat_event = 839 + // client_app_info_request = 840 // removed + // client_app_info_response = 841 // removed + client_steam_usage_event = 842 + client_check_password = 845 + client_reset_password = 846 + client_check_password_response = 848 + client_reset_password_response = 849 + client_session_token = 850 + client_drm_problem_report = 851 + client_set_ignore_friend = 855 + client_set_ignore_friend_response = 856 + client_get_app_ownership_ticket = 857 + client_get_app_ownership_ticket_response = 858 + client_get_lobby_list_response = 860 + // client_get_lobby_metadata = 861 // removed + // client_get_lobby_metadata_response = 862 // removed + // client_vtt_cert = 863 // removed + // client_app_info_update = 866 // removed + // client_app_info_changes = 867 // removed + client_server_list = 880 + client_email_change_response = 891 + client_secret_qa_change_response = 892 + client_drm_blob_request = 896 + client_drm_blob_response = 897 + // client_lookup_key = 898 // removed + // client_lookup_key_response = 899 // removed + + // base_game_server = 900 + gs_disconnect_notice = 901 + gs_status = 903 + gs_user_playing = 905 + gs_status2 = 906 + gs_status_update_unused = 907 + gs_server_type = 908 + gs_player_list = 909 + gs_get_user_achievement_status = 910 + gs_get_user_achievement_status_response = 911 + gs_get_play_stats = 918 + gs_get_play_stats_response = 919 + gs_get_user_group_status = 920 + am_get_user_group_status = 921 + am_get_user_group_status_response = 922 + gs_get_user_group_status_response = 923 + gs_get_reputation = 936 + gs_get_reputation_response = 937 + gs_associate_with_clan = 938 + gs_associate_with_clan_response = 939 + gs_compute_new_player_compatibility = 940 + gs_compute_new_player_compatibility_response = 941 + + // base_admin = 1000 + admin_cmd = 1000 + admin_cmd_response = 1004 + admin_log_listen_request = 1005 + admin_log_event = 1006 + // log_search_request = 1007 // removed + // log_search_response = 1008 // removed + // log_search_cancel = 1009 // removed + universe_data = 1010 + // request_stat_history = 1014 // removed + // stat_history = 1015 // removed + // admin_pw_logon = 1017 // removed + // admin_pw_logon_response = 1018 // removed + admin_spew = 1019 + admin_console_title = 1020 + admin_gc_spew = 1023 + admin_gc_command = 1024 + admin_gc_get_command_list = 1025 + admin_gc_get_command_list_response = 1026 + fbs_connection_data = 1027 + admin_msg_spew = 1028 + + // base_fbs = 1100 + fbs_req_version = 1100 + fbs_version_info = 1101 + fbs_force_refresh = 1102 + fbs_force_bounce = 1103 + fbs_deploy_package = 1104 + fbs_deploy_response = 1105 + fbs_update_bootstrapper = 1106 + fbs_set_state = 1107 + fbs_apply_os_updates = 1108 + fbs_run_cmd_script = 1109 + fbs_reboot_box = 1110 + fbs_set_big_brother_mode = 1111 + fbs_minidump_server = 1112 + // fbs_set_shell_count_obsolete = 1113 // removed + fbs_deploy_hot_fix_package = 1114 + fbs_deploy_hot_fix_response = 1115 + fbs_download_hot_fix = 1116 + fbs_download_hot_fix_response = 1117 + fbs_update_target_config_file = 1118 + fbs_apply_account_cred = 1119 + fbs_apply_account_cred_response = 1120 + fbs_set_shell_count = 1121 + fbs_terminate_shell = 1122 + fbs_query_gm_for_request = 1123 + fbs_query_gm_response = 1124 + fbs_terminate_zombies = 1125 + fbs_info_from_bootstrapper = 1126 + fbs_reboot_box_response = 1127 + fbs_bootstrapper_package_request = 1128 + fbs_bootstrapper_package_response = 1129 + fbs_bootstrapper_get_package_chunk = 1130 + fbs_bootstrapper_get_package_chunk_response = 1131 + fbs_bootstrapper_package_transfer_progress = 1132 + fbs_restart_bootstrapper = 1133 + fbs_pause_frozen_dumps = 1134 + + // base_file_xfer = 1200 + file_xfer_request = 1200 + file_xfer_response = 1201 + file_xfer_data = 1202 + file_xfer_end = 1203 + file_xfer_data_ack = 1204 + + // base_channel_auth = 1300 + channel_auth_challenge = 1300 + channel_auth_response = 1301 + channel_auth_result = 1302 + channel_encrypt_request = 1303 + channel_encrypt_response = 1304 + channel_encrypt_result = 1305 + + // base_bs = 1400 + bs_purchase_start = 1401 + bs_purchase_response = 1402 + bs_authenticate_cc_trans = 1403 + bs_authenticate_cc_trans_response = 1404 + // bs_settle_nova = 1404 // removed + bs_settle_complete = 1406 + // bs_banned_request = 1407 // removed + bs_init_pay_pal_txn = 1408 + bs_init_pay_pal_txn_response = 1409 + bs_get_pay_pal_user_info = 1410 + bs_get_pay_pal_user_info_response = 1411 + // bs_refund_txn = 1413 // removed + // bs_refund_txn_response = 1414 // removed + // bs_get_events = 1415 // removed + // bs_chase_rfr_request = 1416 // removed + bs_payment_instr_ban = 1417 + bs_payment_instr_ban_response = 1418 + // bs_process_gc_reports = 1419 // removed + // bs_process_pp_reports = 1420 // removed + bs_init_gc_bank_xfer_txn = 1421 + bs_init_gc_bank_xfer_txn_response = 1422 + // bs_query_gc_bank_xfer_txn = 1423 // removed + // bs_query_gc_bank_xfer_txn_response = 1424 // removed + bs_commit_gc_txn = 1425 + bs_query_transaction_status = 1426 + bs_query_transaction_status_response = 1427 + // bs_query_cb_order_status = 1428 // removed + // bs_query_cb_order_status_response = 1429 // removed + // bs_run_red_flag_report = 1430 // removed + bs_query_payment_inst_usage = 1431 + bs_query_payment_inst_response = 1432 + bs_query_txn_extended_info = 1433 + bs_query_txn_extended_info_response = 1434 + bs_update_conversion_rates = 1435 + // bs_process_us_bank_reports = 1436 // removed + bs_purchase_run_fraud_checks = 1437 + bs_purchase_run_fraud_checks_response = 1438 + // bs_start_shipping_jobs = 1439 // removed + bs_query_bank_information = 1440 + bs_query_bank_information_response = 1441 + bs_validate_xsolla_signature = 1445 + bs_validate_xsolla_signature_response = 1446 + bs_qiwi_wallet_invoice = 1448 + bs_qiwi_wallet_invoice_response = 1449 + bs_update_inventory_from_pro_pack = 1450 + bs_update_inventory_from_pro_pack_response = 1451 + bs_send_shipping_request = 1452 + bs_send_shipping_request_response = 1453 + bs_get_pro_pack_order_status = 1454 + bs_get_pro_pack_order_status_response = 1455 + bs_check_job_running = 1456 + bs_check_job_running_response = 1457 + bs_reset_package_purchase_rate_limit = 1458 + bs_reset_package_purchase_rate_limit_response = 1459 + bs_update_payment_data = 1460 + bs_update_payment_data_response = 1461 + bs_get_billing_address = 1462 + bs_get_billing_address_response = 1463 + bs_get_credit_card_info = 1464 + bs_get_credit_card_info_response = 1465 + bs_remove_expired_payment_data = 1468 + bs_remove_expired_payment_data_response = 1469 + bs_convert_to_current_keys = 1470 + bs_convert_to_current_keys_response = 1471 + bs_init_purchase = 1472 + bs_init_purchase_response = 1473 + bs_complete_purchase = 1474 + bs_complete_purchase_response = 1475 + bs_prune_card_usage_stats = 1476 + bs_prune_card_usage_stats_response = 1477 + bs_store_bank_information = 1478 + bs_store_bank_information_response = 1479 + bs_verify_posa_key = 1480 + bs_verify_posa_key_response = 1481 + bs_reverse_redeem_posa_key = 1482 + bs_reverse_redeem_posa_key_response = 1483 + bs_query_find_credit_card = 1484 + bs_query_find_credit_card_response = 1485 + bs_status_inquiry_posa_key = 1486 + bs_status_inquiry_posa_key_response = 1487 + // bs_validate_mo_pay_signature = 1488 // obsolete + // bs_validate_mo_pay_signature_response = 1489 // obsolete + // bs_mo_pay_confirm_product_delivery = 1490 // obsolete + // bs_mo_pay_confirm_product_delivery_response = 1491 // obsolete + // bs_generate_mo_pay_md5 = 1492 // obsolete + // bs_generate_mo_pay_md5_response = 1493 // obsolete + bs_boa_compra_confirm_product_delivery = 1494 + bs_boa_compra_confirm_product_delivery_response = 1495 + bs_generate_boa_compra_md5 = 1496 + bs_generate_boa_compra_md5_response = 1497 + bs_commit_wp_txn = 1498 + bs_commit_adyen_txn = 1499 + + // base_ats = 1500 + ats_start_stress_test = 1501 + ats_stop_stress_test = 1502 + ats_run_fail_server_test = 1503 + atsufs_perf_test_task = 1504 + atsufs_perf_test_response = 1505 + ats_cycle_tcm = 1506 + ats_init_drms_stress_test = 1507 + ats_call_test = 1508 + ats_call_test_reply = 1509 + ats_start_external_stress = 1510 + ats_external_stress_job_start = 1511 + ats_external_stress_job_queued = 1512 + ats_external_stress_job_running = 1513 + ats_external_stress_job_stopped = 1514 + ats_external_stress_job_stop_all = 1515 + ats_external_stress_action_result = 1516 + ats_started = 1517 + atscs_perf_test_task = 1518 + atscs_perf_test_response = 1519 + + // base_dp = 1600 + dp_set_publishing_state = 1601 + // dp_game_played_stats = 1602 // removed + dp_unique_players_stat = 1603 + dp_streaming_unique_players_stat = 1604 + // dp_vac_infraction_stats = 1605 // obsolete + // dp_vac_ban_stats = 1606 // obsolete + dp_blocking_stats = 1607 + dp_nat_traversal_stats = 1608 + // dp_steam_usage_event = 1609 // removed + // dp_vac_cert_ban_stats = 1610 // obsolete + // dp_vac_cafe_ban_stats = 1611 // obsolete + dp_cloud_stats = 1612 + dp_achievement_stats = 1613 + // dp_account_creation_stats = 1614 // obsolete + dp_get_player_count = 1615 + dp_get_player_count_response = 1616 + dp_game_servers_players_stats = 1617 + // dp_download_rate_statistics = 1618 // removed + // dp_facebook_statistics = 1619 // obsolete + client_dp_check_special_survey = 1620 + client_dp_check_special_survey_response = 1621 + client_dp_send_special_survey_response = 1622 + client_dp_send_special_survey_response_reply = 1623 + dp_store_sale_statistics = 1624 + client_dp_update_app_job_report = 1625 + // client_dp_steam2_app_started = 1627 // removed + dp_update_content_event = 1626 + client_dp_unsigned_install_script = 1627 + dp_partner_micro_txns = 1628 + dp_partner_micro_txns_response = 1629 + client_dp_content_stats_report = 1630 + dpvr_unique_players_stat = 1631 + + // base_cm = 1700 + cm_set_allow_state = 1701 + cm_spew_allow_state = 1702 + cm_session_rejected = 1703 + cm_set_secrets = 1704 + cm_get_secrets = 1705 + // cm_app_info_response_deprecated = 1703 // removed + + // // base_dss = 1800 // removed + // dss_new_file = 1801 // removed + // dss_current_file_list = 1802 // removed + // dss_synch_list = 1803 // removed + // dss_synch_list_response = 1804 // removed + // dss_synch_subscribe = 1805 // removed + // dss_synch_unsubscribe = 1806 // removed + + // // base_epm = 1900 // removed + // epm_start_process = 1901 // removed + // epm_stop_process = 1902 // removed + // epm_restart_process = 1903 // removed + + // base_gc = 2200 + // gc_send_client = 2200 // removed + // am_relay_to_gc = 2201 // removed + // gc_update_played_state = 2202 // removed + gc_cmd_revive = 2203 + // gc_cmd_bounce = 2204 // removed + // gc_cmd_force_bounce = 2205 // removed + gc_cmd_down = 2206 + gc_cmd_deploy = 2207 + gc_cmd_deploy_response = 2208 + gc_cmd_switch = 2209 + am_refresh_sessions = 2210 + // gc_update_gs_state = 2211 // removed + gc_achievement_awarded = 2212 + gc_system_message = 2213 + // gc_validate_session = 2214 // removed + // gc_validate_session_response = 2215 // removed + gc_cmd_status = 2216 + // gc_register_web_interfaces = 2217 // removed + // gc_register_web_interfaces_deprecated = 2217 // removed + // gc_get_account_details = 2218 // removed + // gc_get_account_details_deprecated = 2218 // removed + gc_inter_app_message = 2219 + gc_get_email_template = 2220 + gc_get_email_template_response = 2221 + // is_relay_to_gch = 2222 // removed "renamed to GCHRelay" + gch_relay = 2222 + // gch_relay_client_to_is = 2223 // removed "renamed to GCHRelayToClient" + gch_relay_to_client = 2223 + gch_update_session = 2224 + gch_request_update_session = 2225 + gch_request_status = 2226 + gch_request_status_response = 2227 + gch_account_vac_status_change = 2228 + gch_spawn_gc = 2229 + gch_spawn_gc_response = 2230 + gch_kill_gc = 2231 + gch_kill_gc_response = 2232 + gch_account_trade_ban_status_change = 2233 + gch_account_lock_status_change = 2234 + gch_vac_verification_change = 2235 + gch_account_phone_number_change = 2236 + gch_account_two_factor_change = 2237 + gch_invite_user_to_lobby = 2238 + + // base_p2_p = 2500 + p2_p_introducer_message = 2502 + + // base_sm = 2900 + sm_expensive_report = 2902 + sm_hourly_report = 2903 + // sm_fishing_report = 2904 // obsolete + sm_partition_renames = 2905 + sm_monitor_space = 2906 + sm_test_next_build_schema_conversion = 2907 + sm_test_next_build_schema_conversion_response = 2908 + // sm_get_schema_conversion_results = 2907 // removed + // sm_get_schema_conversion_results_response = 2908 // removed + + // base_test = 3000 + fail_server = 3000 + job_heartbeat_test = 3001 + job_heartbeat_test_response = 3002 + + // base_fts_range = 3100 + // fts_get_browse_counts = 3101 // removed + // fts_get_browse_counts_response = 3102 // removed + // fts_browse_clans = 3103 // removed + // fts_browse_clans_response = 3104 // removed + // fts_search_clans_by_location = 3105 // removed + // fts_search_clans_by_location_response = 3106 // removed + // fts_search_players_by_location = 3107 // removed + // fts_search_players_by_location_response = 3108 // removed + // fts_clan_deleted = 3109 // removed + // fts_search = 3110 // removed + // fts_search_response = 3111 // removed + // fts_search_status = 3112 // removed + // fts_search_status_response = 3113 // removed + // fts_get_gs_play_stats = 3114 // removed + // fts_get_gs_play_stats_response = 3115 // removed + // fts_get_gs_play_stats_for_server = 3116 // removed + // fts_get_gs_play_stats_for_server_response = 3117 // removed + // fts_report_ip_updates = 3118 // removed + + // base_ccs_range = 3150 + // ccs_get_comments = 3151 // removed + // ccs_get_comments_response = 3152 // removed + // ccs_add_comment = 3153 // removed + // ccs_add_comment_response = 3154 // removed + // ccs_delete_comment = 3155 // removed + // ccs_delete_comment_response = 3156 // removed + // ccs_preload_comments = 3157 // removed + // ccs_notify_comment_count = 3158 // removed + // ccs_get_comments_for_news = 3159 // removed + // ccs_get_comments_for_news_response = 3160 // removed + ccs_delete_all_comments_by_author = 3161 + ccs_delete_all_comments_by_author_response = 3162 + + + // base_lbs_range = 3200 + lbs_set_score = 3201 + lbs_set_score_response = 3202 + lbs_find_or_create_lb = 3203 + lbs_find_or_create_lb_response = 3204 + lbs_get_lb_entries = 3205 + lbs_get_lb_entries_response = 3206 + lbs_get_lb_list = 3207 + lbs_get_lb_list_response = 3208 + lbs_set_lb_details = 3209 + lbs_delete_lb = 3210 + lbs_delete_lb_entry = 3211 + lbs_reset_lb = 3212 + lbs_reset_lb_response = 3213 + lbs_delete_lb_response = 3214 + + // base_ogs = 3400 + ogs_begin_session = 3401 + ogs_begin_session_response = 3402 + ogs_end_session = 3403 + ogs_end_session_response = 3404 + ogs_write_app_session_row = 3406 + + // base_brp = 3600 + // brp_start_shipping_jobs = 3601 // obsolete + // brp_process_us_bank_reports = 3602 // obsolete + // brp_process_gc_reports = 3603 // obsolete + // brp_process_pp_reports = 3604 // obsolete + // brp_settle_nova = 3605 // removed + // brp_settle_cb = 3606 // removed + // brp_commit_gc = 3607 // obsolete + // brp_commit_gc_response = 3608 // obsolete + // brp_find_hung_transactions = 3609 // obsolete + // brp_check_finance_close_out_date = 3610 // obsolete + // brp_process_licenses = 3611 // obsolete + // brp_process_licenses_response = 3612 // obsolete + // brp_remove_expired_payment_data = 3613 // obsolete + // brp_remove_expired_payment_data_response = 3614 // obsolete + // brp_convert_to_current_keys = 3615 // obsolete + // brp_convert_to_current_keys_response = 3616 // obsolete + // brp_prune_card_usage_stats = 3617 // obsolete + // brp_prune_card_usage_stats_response = 3618 // obsolete + // brp_check_activation_codes = 3619 // obsolete + // brp_check_activation_codes_response = 3620 // obsolete + // brp_commit_wp = 3621 // obsolete + // brp_commit_wp_response = 3622 // obsolete + // brp_process_wp_reports = 3623 // obsolete + // brp_process_payment_rules = 3624 // obsolete + // brp_process_partner_payments = 3625 // obsolete + // brp_check_settlement_reports = 3626 // obsolete + // brp_post_tax_to_avalara = 3628 // obsolete + brp_post_transaction_tax = 3629 + brp_post_transaction_tax_response = 3630 + // brp_process_im_reports = 3631 // obsolete + + // base_am_range2 = 4000 + am_create_chat = 4001 + am_create_chat_response = 4002 + // am_update_chat_metadata = 4003 // removed + // am_publish_chat_metadata = 4004 // removed + am_set_profile_url = 4005 + am_get_account_email_address = 4006 + am_get_account_email_address_response = 4007 + // am_request_friend_data = 4008 // removed "renamed to AMRequestClanData" + am_request_clan_data = 4008 + am_route_to_clients = 4009 + am_leave_clan = 4010 + am_clan_permissions = 4011 + am_clan_permissions_response = 4012 + // am_create_clan_event = 4013 // obsolete "renamed to AMCreateClanEventDummyForRateLimiting" + am_create_clan_event_dummy_for_rate_limiting = 4013 + // am_create_clan_event_response = 4014 // obsolete + // am_update_clan_event = 4015 // obsolete "renamed to AMUpdateClanEventDummyForRateLimiting" + am_update_clan_event_dummy_for_rate_limiting = 4015 + // am_update_clan_event_response = 4016 // obsolete + // am_get_clan_events = 4017 // obsolete + // am_get_clan_events_response = 4018 // obsolete + // am_delete_clan_event = 4019 // obsolete + // am_delete_clan_event_response = 4020 // obsolete + am_set_clan_permission_settings = 4021 + am_set_clan_permission_settings_response = 4022 + am_get_clan_permission_settings = 4023 + am_get_clan_permission_settings_response = 4024 + am_publish_chat_room_info = 4025 + client_chat_room_info = 4026 + // am_create_clan_announcement = 4027 // removed + // am_create_clan_announcement_response = 4028 // removed + // am_update_clan_announcement = 4029 // removed + // am_update_clan_announcement_response = 4030 // removed + // am_get_clan_announcements_count = 4031 // removed + // am_get_clan_announcements_count_response = 4032 // removed + // am_get_clan_announcements = 4033 // removed + // am_get_clan_announcements_response = 4034 // removed + // am_delete_clan_announcement = 4035 // removed + // am_delete_clan_announcement_response = 4036 // removed + // am_get_single_clan_announcement = 4037 // removed + // am_get_single_clan_announcement_response = 4038 // removed + am_get_clan_history = 4039 + am_get_clan_history_response = 4040 + am_get_clan_permission_bits = 4041 + am_get_clan_permission_bits_response = 4042 + am_set_clan_permission_bits = 4043 + am_set_clan_permission_bits_response = 4044 + am_session_info_request = 4045 + am_session_info_response = 4046 + am_validate_wg_token = 4047 + // am_get_single_clan_event = 4048 // obsolete + // am_get_single_clan_event_response = 4049 // obsolete + am_get_clan_rank = 4050 + am_get_clan_rank_response = 4051 + am_set_clan_rank = 4052 + am_set_clan_rank_response = 4053 + am_get_clan_potw = 4054 + am_get_clan_potw_response = 4055 + am_set_clan_potw = 4056 + am_set_clan_potw_response = 4057 + // am_request_chat_metadata = 4058 // removed + am_dump_user = 4059 + am_kick_user_from_clan = 4060 + am_add_founder_to_clan = 4061 + am_validate_wg_token_response = 4062 + // am_set_community_state = 4063 // obsolete + am_set_account_details = 4064 + am_get_chat_ban_list = 4065 + am_get_chat_ban_list_response = 4066 + am_un_ban_from_chat = 4067 + am_set_clan_details = 4068 + am_get_account_links = 4069 + am_get_account_links_response = 4070 + am_set_account_links = 4071 + am_set_account_links_response = 4072 + // am_get_user_game_stats = 4073 // obsolete "renamed to UGSGetUserGameStats" + ugs_get_user_game_stats = 4073 + // am_get_user_game_stats_response = 4074 // obsolete "renamed to UGSGetUserGameStatsResponse" + ugs_get_user_game_stats_response = 4074 + am_check_clan_membership = 4075 + am_get_clan_members = 4076 + am_get_clan_members_response = 4077 + // am_join_public_clan = 4078 // obsolete + am_notify_chat_of_clan_change = 4079 + am_resubmit_purchase = 4080 + am_add_friend = 4081 + am_add_friend_response = 4082 + am_remove_friend = 4083 + am_dump_clan = 4084 + am_change_clan_owner = 4085 + am_cancel_easy_collect = 4086 + am_cancel_easy_collect_response = 4087 + // am_get_clan_membership_list = 4088 // removed + // am_get_clan_membership_list_response = 4089 // removed + am_clans_in_common = 4090 + am_clans_in_common_response = 4091 + am_is_valid_account_id = 4092 + // am_convert_clan = 4093 // obsolete + // am_get_gift_target_list_relay = 4094 // removed + am_wipe_friends_list = 4095 + am_set_ignored = 4096 + am_clans_in_common_count_response = 4097 + am_friends_list = 4098 + am_friends_list_response = 4099 + am_friends_in_common = 4100 + am_friends_in_common_response = 4101 + am_friends_in_common_count_response = 4102 + am_clans_in_common_count = 4103 + am_challenge_verdict = 4104 + am_challenge_notification = 4105 + am_find_gs_by_ip = 4106 + am_found_gs_by_ip = 4107 + am_gift_revoked = 4108 + // am_create_account_record = 4109 // obsolete + am_user_clan_list = 4110 + am_user_clan_list_response = 4111 + am_get_account_details2 = 4112 + am_get_account_details_response2 = 4113 + am_set_community_profile_settings = 4114 + am_set_community_profile_settings_response = 4115 + am_get_community_privacy_state = 4116 + am_get_community_privacy_state_response = 4117 + am_check_clan_invite_rate_limiting = 4118 + // am_get_user_achievement_status = 4119 // obsolete "renamed to UGSGetUserAchievementStatus" + ugs_get_user_achievement_status = 4119 + am_get_ignored = 4120 + am_get_ignored_response = 4121 + am_set_ignored_response = 4122 + am_set_friend_relationship_none = 4123 + am_get_friend_relationship = 4124 + am_get_friend_relationship_response = 4125 + am_service_modules_cache = 4126 + am_service_modules_call = 4127 + am_service_modules_call_response = 4128 + // am_get_captcha_data_for_ip = 4129 // obsolete + // am_get_captcha_data_for_ip_response = 4130 // obsolete + // am_validate_captcha_data_for_ip = 4131 // obsolete + // am_validate_captcha_data_for_ip_response = 4132 // obsolete + // am_track_failed_auth_by_ip = 4133 // obsolete + // am_get_captcha_data_by_gid = 4134 // obsolete + // am_get_captcha_data_by_gid_response = 4135 // obsolete + // am_get_lobby_list = 4136 // removed + // am_get_lobby_list_response = 4137 // removed + // am_get_lobby_metadata = 4138 // removed + // am_get_lobby_metadata_response = 4139 // removed + community_add_friend_news = 4140 + // am_add_clan_news = 4141 // removed + // am_write_news = 4142 // removed + am_find_clan_user = 4143 + am_find_clan_user_response = 4144 + am_ban_from_chat = 4145 + // am_get_user_history_response = 4146 // removed + am_get_user_news_subscriptions = 4147 + am_get_user_news_subscriptions_response = 4148 + am_set_user_news_subscriptions = 4149 + // am_get_user_news = 4150 // removed + // am_get_user_news_response = 4151 // removed + am_send_queued_emails = 4152 + am_set_license_flags = 4153 + // am_get_user_history = 4154 // removed + community_delete_user_news = 4155 + am_allow_user_files_request = 4156 + am_allow_user_files_response = 4157 + am_get_account_status = 4158 + am_get_account_status_response = 4159 + am_edit_ban_reason = 4160 + am_check_clan_membership_response = 4161 + am_probe_clan_membership_list = 4162 + am_probe_clan_membership_list_response = 4163 + ugs_get_user_achievement_status_response = 4164 + am_get_friends_lobbies = 4165 + am_get_friends_lobbies_response = 4166 + am_get_user_friend_news_response = 4172 + community_get_user_friend_news = 4173 + am_get_user_clans_news_response = 4174 + am_get_user_clans_news = 4175 + // am_store_init_purchase = 4176 // removed + // am_store_init_purchase_response = 4177 // removed + // am_store_get_final_price = 4178 // removed + // am_store_get_final_price_response = 4179 // removed + // am_store_complete_purchase = 4180 // removed + // am_store_cancel_purchase = 4181 // removed + // am_store_purchase_response = 4182 // removed + // am_create_account_record_in_steam3 = 4183 // removed + am_get_previous_cb_account = 4184 + am_get_previous_cb_account_response = 4185 + // am_update_billing_address = 4186 // removed + // am_update_billing_address_response = 4187 // removed + // am_get_billing_address = 4188 // removed + // am_get_billing_address_response = 4189 // removed + am_get_user_license_history = 4190 + am_get_user_license_history_response = 4191 + am_support_change_password = 4194 + am_support_change_email = 4195 + // am_support_change_secret_qa = 4196 // removed + am_reset_user_verification_gs_by_ip = 4197 + am_update_gs_play_stats = 4198 + am_support_enable_or_disable = 4199 + // am_get_comments = 4200 // removed + // am_get_comments_response = 4201 // removed + // am_add_comment = 4202 // removed + // am_add_comment_response = 4203 // removed + // am_delete_comment = 4204 // removed + // am_delete_comment_response = 4205 // removed + am_get_purchase_status = 4206 + am_support_is_account_enabled = 4209 + am_support_is_account_enabled_response = 4210 + // am_get_user_stats = 4211 // obsolete "renamed to UGSGetUserStats" + ugs_get_user_stats = 4211 + am_support_kick_session = 4212 + amgs_search = 4213 + marketing_message_update = 4216 + // am_route_friend_msg = 4219 // obsolete "renamed to ChatServerRouteFriendMsg" + chat_server_route_friend_msg = 4219 + am_ticket_auth_request_or_response = 4220 + am_verify_depot_management_rights = 4222 + am_verify_depot_management_rights_response = 4223 + am_add_free_license = 4224 + // am_get_user_friends_minutes_played = 4225 // removed + // am_get_user_friends_minutes_played_response = 4226 // removed + // am_get_user_minutes_played = 4227 // removed + // am_get_user_minutes_played_response = 4228 // removed + am_validate_email_link = 4231 + am_validate_email_link_response = 4232 + // am_add_users_to_marketing_treatment = 4234 // removed + // am_store_user_stats = 4236 // obsolete "renamed to UGSStoreUserStats" + ugs_store_user_stats = 4236 + // am_get_user_gameplay_info = 4237 // removed + // am_get_user_gameplay_info_response = 4238 // removed + // am_get_card_list = 4239 // removed + // am_get_card_list_response = 4240 // removed + am_delete_stored_card = 4241 + am_revoke_legacy_game_keys = 4242 + am_get_wallet_details = 4244 + am_get_wallet_details_response = 4245 + am_delete_stored_payment_info = 4246 + am_get_stored_payment_summary = 4247 + am_get_stored_payment_summary_response = 4248 + am_get_wallet_conversion_rate = 4249 + am_get_wallet_conversion_rate_response = 4250 + am_convert_wallet = 4251 + am_convert_wallet_response = 4252 + // am_relay_get_friends_who_play_game = 4253 // removed + // am_relay_get_friends_who_play_game_response = 4254 // removed + am_set_pre_approval = 4255 + am_set_pre_approval_response = 4256 + // am_marketing_treatment_update = 4257 // removed + am_create_refund = 4258 + // am_create_refund_response = 4259 // obsolete + am_create_chargeback = 4260 + // am_create_chargeback_response = 4261 // obsolete + am_create_dispute = 4262 + // am_create_dispute_response = 4263 // obsolete + am_clear_dispute = 4264 + // am_clear_dispute_response = 4265 // obsolete "renamed to AMCreateFinancialAdjustment" + am_create_financial_adjustment = 4265 + am_player_nickname_list = 4266 + am_player_nickname_list_response = 4267 + am_set_drm_test_config = 4268 + am_get_user_current_game_info = 4269 + am_get_user_current_game_info_response = 4270 + am_get_gs_player_list = 4271 + am_get_gs_player_list_response = 4272 + // am_update_persona_state_cache = 4275 // removed + am_get_game_members = 4276 + am_get_game_members_response = 4277 + am_get_steam_id_for_micro_txn = 4278 + am_get_steam_id_for_micro_txn_response = 4279 + // am_add_publisher_user = 4280 // obsolete "renamed to AMSetPartnerMember" + am_set_partner_member = 4280 + am_remove_publisher_user = 4281 + am_get_user_license_list = 4282 + am_get_user_license_list_response = 4283 + am_reload_game_group_policy = 4284 + am_add_free_license_response = 4285 + amvac_status_update = 4286 + am_get_account_details = 4287 + am_get_account_details_response = 4288 + am_get_player_link_details = 4289 + am_get_player_link_details_response = 4290 + // am_subscribe_to_persona_feed = 4291 // removed + // am_get_user_vac_ban_list = 4292 // removed + // am_get_user_vac_ban_list_response = 4293 // removed + am_get_account_flags_for_wg_spoofing = 4294 + am_get_account_flags_for_wg_spoofing_response = 4295 + // am_get_friends_wishlist_info = 4296 // removed + // am_get_friends_wishlist_info_response = 4297 // removed + am_get_clan_officers = 4298 + am_get_clan_officers_response = 4299 + am_name_change = 4300 + am_get_name_history = 4301 + am_get_name_history_response = 4302 + am_update_provider_status = 4305 + // am_clear_persona_metadata_blob = 4306 // removed + am_support_remove_account_security = 4307 + am_is_account_in_captcha_grace_period = 4308 + am_is_account_in_captcha_grace_period_response = 4309 + am_account_ps3_unlink = 4310 + am_account_ps3_unlink_response = 4311 + // am_store_user_stats_response = 4312 // obsolete "renamed to UGSStoreUserStatsResponse" + ugs_store_user_stats_response = 4312 + am_get_account_psn_info = 4313 + am_get_account_psn_info_response = 4314 + am_authenticated_player_list = 4315 + am_get_user_gifts = 4316 + am_get_user_gifts_response = 4317 + am_transfer_locked_gifts = 4320 + am_transfer_locked_gifts_response = 4321 + am_player_hosted_on_game_server = 4322 + am_get_account_ban_info = 4323 + am_get_account_ban_info_response = 4324 + am_record_ban_enforcement = 4325 + am_rollback_gift_transfer = 4326 + am_rollback_gift_transfer_response = 4327 + am_handle_pending_transaction = 4328 + am_request_clan_details = 4329 + am_delete_stored_paypal_agreement = 4330 + am_game_server_update = 4331 + am_game_server_remove = 4332 + am_get_paypal_agreements = 4333 + am_get_paypal_agreements_response = 4334 + am_game_server_player_compatibility_check = 4335 + am_game_server_player_compatibility_check_response = 4336 + am_renew_license = 4337 + am_get_account_community_ban_info = 4338 + am_get_account_community_ban_info_response = 4339 + am_game_server_account_change_password = 4340 + am_game_server_account_delete_account = 4341 + am_renew_agreement = 4342 + // am_send_email = 4343 // removed + am_xsolla_payment = 4344 + am_xsolla_payment_response = 4345 + am_acct_allowed_to_purchase = 4346 + am_acct_allowed_to_purchase_response = 4347 + am_swap_kiosk_deposit = 4348 + am_swap_kiosk_deposit_response = 4349 + am_set_user_gift_unowned = 4350 + am_set_user_gift_unowned_response = 4351 + am_claim_unowned_user_gift = 4352 + am_claim_unowned_user_gift_response = 4353 + am_set_clan_name = 4354 + am_set_clan_name_response = 4355 + am_grant_coupon = 4356 + am_grant_coupon_response = 4357 + am_is_package_restricted_in_user_country = 4358 + am_is_package_restricted_in_user_country_response = 4359 + am_handle_pending_transaction_response = 4360 + am_grant_guest_passes2 = 4361 + am_grant_guest_passes2_response = 4362 + // am_session_query = 4363 // obsolete + // am_session_query_response = 4364 // obsolete + am_get_player_ban_details = 4365 + am_get_player_ban_details_response = 4366 + am_finalize_purchase = 4367 + am_finalize_purchase_response = 4368 + am_persona_change_response = 4372 + am_get_clan_details_for_forum_creation = 4373 + am_get_clan_details_for_forum_creation_response = 4374 + am_get_pending_notification_count = 4375 + am_get_pending_notification_count_response = 4376 + am_password_hash_upgrade = 4377 + // am_mo_pay_payment = 4378 // obsolete + // am_mo_pay_payment_response = 4379 // obsolete + am_boa_compra_payment = 4380 + am_boa_compra_payment_response = 4381 + // am_expire_captcha_by_gid = 4382 // obsolete + am_complete_external_purchase = 4383 + am_complete_external_purchase_response = 4384 + am_resolve_negative_wallet_credits = 4385 + am_resolve_negative_wallet_credits_response = 4386 + // am_payelp_payment = 4387 // obsolete + // am_payelp_payment_response = 4388 // obsolete + am_player_get_clan_basic_details = 4389 + am_player_get_clan_basic_details_response = 4390 + ammol_payment = 4391 + ammol_payment_response = 4392 + get_user_ip_country = 4393 + get_user_ip_country_response = 4394 + notification_of_suspicious_activity = 4395 + am_degica_payment = 4396 + am_degica_payment_response = 4397 + ame_club_payment = 4398 + ame_club_payment_response = 4399 + am_pay_pal_payments_hub_payment = 4400 + am_pay_pal_payments_hub_payment_response = 4401 + am_two_factor_recover_authenticator_request = 4402 + am_two_factor_recover_authenticator_response = 4403 + am_smart2_pay_payment = 4404 + am_smart2_pay_payment_response = 4405 + am_validate_password_reset_code_and_send_sms_request = 4406 + am_validate_password_reset_code_and_send_sms_response = 4407 + am_get_account_reset_details_request = 4408 + am_get_account_reset_details_response = 4409 + am_bit_pay_payment = 4410 + am_bit_pay_payment_response = 4411 + am_send_account_info_update = 4412 + am_send_scheduled_gift = 4413 + am_nodwin_payment = 4414 + am_nodwin_payment_response = 4415 + am_resolve_wallet_revoke = 4416 + am_resolve_wallet_reverse_revoke = 4417 + am_funded_payment = 4418 + am_funded_payment_response = 4419 + am_request_persona_update_for_chat_server = 4420 + am_perfect_world_payment = 4421 + am_perfect_world_payment_response = 4422 + + // base_ps_range = 5000 + ps_create_shopping_cart = 5001 + ps_create_shopping_cart_response = 5002 + ps_is_valid_shopping_cart = 5003 + ps_is_valid_shopping_cart_response = 5004 + ps_add_package_to_shopping_cart = 5005 + ps_add_package_to_shopping_cart_response = 5006 + ps_remove_line_item_from_shopping_cart = 5007 + ps_remove_line_item_from_shopping_cart_response = 5008 + ps_get_shopping_cart_contents = 5009 + ps_get_shopping_cart_contents_response = 5010 + ps_add_wallet_credit_to_shopping_cart = 5011 + ps_add_wallet_credit_to_shopping_cart_response = 5012 + + // base_ufs_range = 5200 + client_ufs_upload_file_request = 5202 + client_ufs_upload_file_response = 5203 + client_ufs_upload_file_chunk = 5204 + client_ufs_upload_file_finished = 5205 + client_ufs_get_file_list_for_app = 5206 + client_ufs_get_file_list_for_app_response = 5207 + client_ufs_download_request = 5210 + client_ufs_download_response = 5211 + client_ufs_download_chunk = 5212 + client_ufs_login_request = 5213 + client_ufs_login_response = 5214 + ufs_reload_partition_info = 5215 + client_ufs_transfer_heartbeat = 5216 + ufs_synchronize_file = 5217 + ufs_synchronize_file_response = 5218 + client_ufs_delete_file_request = 5219 + client_ufs_delete_file_response = 5220 + // ufs_download_request = 5221 // removed + // ufs_download_response = 5222 // removed + // ufs_download_chunk = 5223 // removed + client_ufs_get_ugc_details = 5226 + client_ufs_get_ugc_details_response = 5227 + ufs_update_file_flags = 5228 + ufs_update_file_flags_response = 5229 + client_ufs_get_single_file_info = 5230 + client_ufs_get_single_file_info_response = 5231 + client_ufs_share_file = 5232 + client_ufs_share_file_response = 5233 + ufs_reload_account = 5234 + ufs_reload_account_response = 5235 + ufs_update_record_batched = 5236 + ufs_update_record_batched_response = 5237 + ufs_migrate_file = 5238 + ufs_migrate_file_response = 5239 + ufs_get_ugcur_ls = 5240 + ufs_get_ugcur_ls_response = 5241 + ufs_http_upload_file_finish_request = 5242 + ufs_http_upload_file_finish_response = 5243 + ufs_download_start_request = 5244 + ufs_download_start_response = 5245 + ufs_download_chunk_request = 5246 + ufs_download_chunk_response = 5247 + ufs_download_finish_request = 5248 + ufs_download_finish_response = 5249 + ufs_flush_url_cache = 5250 + // ufs_upload_commit = 5251 // obsolete "renamed to ClientUFSUploadCommit" + client_ufs_upload_commit = 5251 + // ufs_upload_commit_response = 5252 // obsolete "renamed to ClientUFSUploadCommitResponse" + client_ufs_upload_commit_response = 5252 + ufs_migrate_file_app_id = 5253 + ufs_migrate_file_app_id_response = 5254 + + // base_client2 = 5400 + client_request_forgotten_password_email = 5401 + client_request_forgotten_password_email_response = 5402 + client_create_account_response = 5403 + client_reset_forgotten_password = 5404 + client_reset_forgotten_password_response = 5405 + // client_create_account2 = 5406 // obsolete + client_inform_of_reset_forgotten_password = 5407 + client_inform_of_reset_forgotten_password_response = 5408 + // client_anon_user_log_on_deprecated = 5409 // removed + client_games_played_with_data_blob = 5410 + client_update_user_game_info = 5411 + client_file_to_download = 5412 + client_file_to_download_response = 5413 + client_lbs_set_score = 5414 + client_lbs_set_score_response = 5415 + client_lbs_find_or_create_lb = 5416 + client_lbs_find_or_create_lb_response = 5417 + client_lbs_get_lb_entries = 5418 + client_lbs_get_lb_entries_response = 5419 + // client_marketing_message_update = 5420 // removed + client_chat_declined = 5426 + client_friend_msg_incoming = 5427 + // client_auth_list_deprecated = 5428 // removed + client_ticket_auth_complete = 5429 + client_is_limited_account = 5430 + client_request_auth_list = 5431 + client_auth_list = 5432 + client_stat = 5433 + client_p2_p_connection_info = 5434 + client_p2_p_connection_fail_info = 5435 + // client_get_number_of_current_players = 5436 // removed + // client_get_number_of_current_players_response = 5437 // removed + client_get_depot_decryption_key = 5438 + client_get_depot_decryption_key_response = 5439 + gs_perform_hardware_survey = 5440 + // client_get_app_beta_passwords = 5441 // removed + // client_get_app_beta_passwords_response = 5442 // removed + client_enable_test_license = 5443 + client_enable_test_license_response = 5444 + client_disable_test_license = 5445 + client_disable_test_license_response = 5446 + client_request_validation_mail = 5448 + client_request_validation_mail_response = 5449 + client_check_app_beta_password = 5450 + client_check_app_beta_password_response = 5451 + client_to_gc = 5452 + client_from_gc = 5453 + client_request_change_mail = 5454 + client_request_change_mail_response = 5455 + client_email_addr_info = 5456 + client_password_change3 = 5457 + client_email_change3 = 5458 + client_personal_qa_change3 = 5459 + client_reset_forgotten_password3 = 5460 + client_request_forgotten_password_email3 = 5461 + // client_create_account3 = 5462 // removed + client_new_login_key = 5463 + client_new_login_key_accepted = 5464 + // client_log_on_with_hash_deprecated = 5465 // removed + client_store_user_stats2 = 5466 + client_stats_updated = 5467 + client_activate_oem_license = 5468 + client_register_oem_machine = 5469 + client_register_oem_machine_response = 5470 + client_requested_client_stats = 5480 + client_stat2_int32 = 5481 + client_stat2 = 5482 + client_verify_password = 5483 + client_verify_password_response = 5484 + client_drm_download_request = 5485 + client_drm_download_response = 5486 + client_drm_final_result = 5487 + client_get_friends_who_play_game = 5488 + client_get_friends_who_play_game_response = 5489 + client_ogs_begin_session = 5490 + client_ogs_begin_session_response = 5491 + client_ogs_end_session = 5492 + client_ogs_end_session_response = 5493 + client_ogs_write_row = 5494 + client_drm_test = 5495 + client_drm_test_result = 5496 + client_server_unavailable = 5500 + client_servers_available = 5501 + client_register_auth_ticket_with_cm = 5502 + client_gc_msg_failed = 5503 + client_micro_txn_auth_request = 5504 + client_micro_txn_authorize = 5505 + client_micro_txn_authorize_response = 5506 + client_app_minutes_played_data = 5507 + client_get_micro_txn_info = 5508 + client_get_micro_txn_info_response = 5509 + client_marketing_message_update2 = 5510 + client_deregister_with_server = 5511 + client_subscribe_to_persona_feed = 5512 + client_logon = 5514 + client_get_client_details = 5515 + client_get_client_details_response = 5516 + client_report_overlay_detour_failure = 5517 + client_get_client_app_list = 5518 + client_get_client_app_list_response = 5519 + client_install_client_app = 5520 + client_install_client_app_response = 5521 + client_uninstall_client_app = 5522 + client_uninstall_client_app_response = 5523 + client_set_client_app_update_state = 5524 + client_set_client_app_update_state_response = 5525 + client_request_encrypted_app_ticket = 5526 + client_request_encrypted_app_ticket_response = 5527 + client_wallet_info_update = 5528 + client_lbs_set_ugc = 5529 + client_lbs_set_ugc_response = 5530 + client_am_get_clan_officers = 5531 + client_am_get_clan_officers_response = 5532 + // client_check_file_signature = 5533 // removed + // client_check_file_signature_response = 5534 // removed + client_friend_profile_info = 5535 + client_friend_profile_info_response = 5536 + client_update_machine_auth = 5537 + client_update_machine_auth_response = 5538 + client_read_machine_auth = 5539 + client_read_machine_auth_response = 5540 + client_request_machine_auth = 5541 + client_request_machine_auth_response = 5542 + client_screenshots_changed = 5543 + // client_email_change4 = 5544 // obsolete + // client_email_change_response4 = 5545 // obsolete + client_get_cdn_auth_token = 5546 + client_get_cdn_auth_token_response = 5547 + client_download_rate_statistics = 5548 + client_request_account_data = 5549 + client_request_account_data_response = 5550 + client_reset_forgotten_password4 = 5551 + client_hide_friend = 5552 + client_friends_groups_list = 5553 + client_get_clan_activity_counts = 5554 + client_get_clan_activity_counts_response = 5555 + client_ogs_report_string = 5556 + client_ogs_report_bug = 5557 + client_sent_logs = 5558 + client_logon_game_server = 5559 + am_client_create_friends_group = 5560 + am_client_create_friends_group_response = 5561 + am_client_delete_friends_group = 5562 + am_client_delete_friends_group_response = 5563 + // am_client_rename_friends_group = 5564 // obsolete "renamed to AMClientManageFriendsGroup" + am_client_manage_friends_group = 5564 + // am_client_rename_friends_group_response = 5565 // obsolete "renamed to AMClientManageFriendsGroupResponse" + am_client_manage_friends_group_response = 5565 + am_client_add_friend_to_group = 5566 + am_client_add_friend_to_group_response = 5567 + am_client_remove_friend_from_group = 5568 + am_client_remove_friend_from_group_response = 5569 + client_am_get_persona_name_history = 5570 + client_am_get_persona_name_history_response = 5571 + client_request_free_license = 5572 + client_request_free_license_response = 5573 + client_drm_download_request_with_crash_data = 5574 + client_auth_list_ack = 5575 + client_item_announcements = 5576 + client_request_item_announcements = 5577 + client_friend_msg_echo_to_sender = 5578 + // client_change_steam_guard_options = 5579 // removed + // client_change_steam_guard_options_response = 5580 // removed + client_ogs_game_server_ping_sample = 5581 + client_comment_notifications = 5582 + client_request_comment_notifications = 5583 + client_persona_change_response = 5584 + client_request_web_api_authenticate_user_nonce = 5585 + client_request_web_api_authenticate_user_nonce_response = 5586 + client_player_nickname_list = 5587 + am_client_set_player_nickname = 5588 + am_client_set_player_nickname_response = 5589 + // client_request_o_auth_token_for_app = 5590 // removed + // client_request_o_auth_token_for_app_response = 5591 // removed + // client_create_account_proto = 5590 // obsolete + // client_create_account_proto_response = 5591 // obsolete + client_get_number_of_current_players_dp = 5592 + client_get_number_of_current_players_dp_response = 5593 + // client_service_method = 5594 // obsolete "renamed to ClientServiceMethodLegacy" + client_service_method_legacy = 5594 + // client_service_method_response = 5595 // obsolete "renamed to ClientServiceMethodLegacyResponse" + client_service_method_legacy_response = 5595 + client_friend_user_status_published = 5596 + client_current_ui_mode = 5597 + client_vanity_url_changed_notification = 5598 + client_user_notifications = 5599 + + // base_dfs = 5600 + dfs_get_file = 5601 + dfs_install_local_file = 5602 + dfs_connection = 5603 + dfs_connection_reply = 5604 + client_dfs_authenticate_request = 5605 + client_dfs_authenticate_response = 5606 + client_dfs_end_session = 5607 + dfs_purge_file = 5608 + dfs_route_file = 5609 + dfs_get_file_from_server = 5610 + dfs_accepted_response = 5611 + dfs_request_pingback = 5612 + dfs_recv_transmit_file = 5613 + dfs_send_transmit_file = 5614 + dfs_request_pingback2 = 5615 + dfs_response_pingback2 = 5616 + client_dfs_download_status = 5617 + dfs_start_transfer = 5618 + dfs_transfer_complete = 5619 + dfs_route_file_response = 5620 + client_networking_cert_request = 5621 + client_networking_cert_request_response = 5622 + client_challenge_request = 5623 + client_challenge_response = 5624 + badge_crafted_notification = 5625 + client_networking_mobile_cert_request = 5626 + client_networking_mobile_cert_request_response = 5627 + + // base_mds = 5800 + // client_mds_login_request = 5801 // removed + // client_mds_login_response = 5802 // removed + // client_mds_upload_manifest_request = 5803 // removed + // client_mds_upload_manifest_response = 5804 // removed + // client_mds_transmit_manifest_data_chunk = 5805 // removed + // client_mds_heartbeat = 5806 // removed + // client_mds_upload_depot_chunks = 5807 // removed + // client_mds_upload_depot_chunks_response = 5808 // removed + // client_mds_init_depot_build_request = 5809 // removed + // client_mds_init_depot_build_response = 5810 // removed + am_to_mds_get_depot_decryption_key = 5812 + mds_to_am_get_depot_decryption_key_response = 5813 + // mds_get_versions_for_depot = 5814 // removed + // mds_get_versions_for_depot_response = 5815 // removed + // mds_set_public_version_for_depot = 5816 // removed + // mds_set_public_version_for_depot_response = 5817 // removed + // client_mds_init_workshop_build_request = 5816 // removed + // client_mds_init_workshop_build_response = 5817 // removed + // client_mds_get_depot_manifest = 5818 // removed + // client_mds_get_depot_manifest_response = 5819 // removed + // client_mds_get_depot_manifest_chunk = 5820 // removed + // client_mds_upload_rate_test = 5823 // removed + // client_mds_upload_rate_test_response = 5824 // removed + // mds_download_depot_chunks_ack = 5825 // removed + // mds_content_server_stats_broadcast = 5826 // removed + mds_content_server_config_request = 5827 + mds_content_server_config = 5828 + mds_get_depot_manifest = 5829 + mds_get_depot_manifest_response = 5830 + mds_get_depot_manifest_chunk = 5831 + mds_get_depot_chunk = 5832 + mds_get_depot_chunk_response = 5833 + mds_get_depot_chunk_chunk = 5834 + // mds_update_content_server_config = 5835 // removed + // mds_get_server_list_for_user = 5836 // obsolete + // mds_get_server_list_for_user_response = 5837 // obsolete + // client_mds_register_app_build = 5838 // removed + // client_mds_register_app_build_response = 5839 // removed + // client_mds_set_app_build_live = 5840 // removed + // client_mds_set_app_build_live_response = 5841 // removed + // client_mds_get_prev_depot_build = 5842 // removed + // client_mds_get_prev_depot_build_response = 5843 // removed + mds_to_cs_flush_chunk = 5844 + // client_mds_sign_install_script = 5845 // removed + // client_mds_sign_install_script_response = 5846 // removed + mds_migrate_chunk = 5847 + mds_migrate_chunk_response = 5848 + mds_to_cs_flush_manifest = 5849 + + // cs_base = 6200 + cs_ping = 6201 + cs_ping_response = 6202 + + // gms_base = 6400 + gms_game_server_replicate = 6401 + client_gms_server_query = 6403 + gms_client_server_query_response = 6404 + amgms_game_server_update = 6405 + amgms_game_server_remove = 6406 + game_server_out_of_date = 6407 + + // device_authorization_base = 6500 + client_authorize_local_device_request = 6501 + // client_authorize_local_device = 6502 // removed + client_authorize_local_device_response = 6502 + client_deauthorize_device_request = 6503 + client_deauthorize_device = 6504 + client_use_local_device_authorizations = 6505 + client_get_authorized_devices = 6506 + client_get_authorized_devices_response = 6507 + am_notify_session_device_authorized = 6508 + client_authorize_local_device_notification = 6509 + + // mms_base = 6600 + client_mms_create_lobby = 6601 + client_mms_create_lobby_response = 6602 + client_mms_join_lobby = 6603 + client_mms_join_lobby_response = 6604 + client_mms_leave_lobby = 6605 + client_mms_leave_lobby_response = 6606 + client_mms_get_lobby_list = 6607 + client_mms_get_lobby_list_response = 6608 + client_mms_set_lobby_data = 6609 + client_mms_set_lobby_data_response = 6610 + client_mms_get_lobby_data = 6611 + client_mms_lobby_data = 6612 + client_mms_send_lobby_chat_msg = 6613 + client_mms_lobby_chat_msg = 6614 + client_mms_set_lobby_owner = 6615 + client_mms_set_lobby_owner_response = 6616 + client_mms_set_lobby_game_server = 6617 + client_mms_lobby_game_server_set = 6618 + client_mms_user_joined_lobby = 6619 + client_mms_user_left_lobby = 6620 + client_mms_invite_to_lobby = 6621 + client_mms_flush_frenemy_list_cache = 6622 + client_mms_flush_frenemy_list_cache_response = 6623 + client_mms_set_lobby_linked = 6624 + client_mms_set_ratelimit_policy_on_client = 6625 + client_mms_get_lobby_status = 6626 + client_mms_get_lobby_status_response = 6627 + mms_get_lobby_list = 6628 + mms_get_lobby_list_response = 6629 + + // non_std_msg_base = 6800 + non_std_msg_memcached = 6801 + non_std_msg_http_server = 6802 + non_std_msg_http_client = 6803 + non_std_msg_wg_response = 6804 + non_std_msg_php_simulator = 6805 + non_std_msg_chase = 6806 + non_std_msg_dfs_transfer = 6807 + non_std_msg_tests = 6808 + non_std_msg_um_qpipe_aapl = 6809 + non_std_msg_syslog = 6810 + non_std_msg_logsink = 6811 + non_std_msg_steam2_emulator = 6812 + non_std_msg_rtmp_server = 6813 + non_std_msg_web_socket = 6814 + non_std_msg_redis = 6815 + + // uds_base = 7000 + client_udsp2_p_session_started = 7001 + client_udsp2_p_session_ended = 7002 + uds_render_user_auth = 7003 + uds_render_user_auth_response = 7004 + // client_uds_invite_to_game = 7005 // obsolete "renamed to ClientInviteToGame" + client_invite_to_game = 7005 + // uds_find_session = 7006 // removed "renamed to UDSHasSession" + uds_has_session = 7006 + // uds_find_session_response = 7007 // removed "renamed to UDSHasSessionResponse" + uds_has_session_response = 7007 + + // mpas_base = 7100 + mpas_vac_ban_reset = 7101 + + // kgs_base = 7200 + // kgs_allocate_key_range = 7201 // removed + // kgs_allocate_key_range_response = 7202 // removed + // kgs_generate_keys = 7203 // removed + // kgs_generate_keys_response = 7204 // removed + // kgs_remap_keys = 7205 // removed + // kgs_remap_keys_response = 7206 // removed + // kgs_generate_game_stop_wc_keys = 7207 // removed + // kgs_generate_game_stop_wc_keys_response = 7208 // removed + + // ucm_base = 7300 + client_ucm_add_screenshot = 7301 + client_ucm_add_screenshot_response = 7302 + // ucm_validate_object_exists = 7303 // removed + // ucm_validate_object_exists_response = 7304 // removed + ucm_reset_community_content = 7307 + ucm_reset_community_content_response = 7308 + client_ucm_delete_screenshot = 7309 + client_ucm_delete_screenshot_response = 7310 + client_ucm_publish_file = 7311 + client_ucm_publish_file_response = 7312 + // client_ucm_get_published_file_details = 7313 // removed + // client_ucm_get_published_file_details_response = 7314 // removed + client_ucm_delete_published_file = 7315 + client_ucm_delete_published_file_response = 7316 + client_ucm_enumerate_user_published_files = 7317 + client_ucm_enumerate_user_published_files_response = 7318 + // client_ucm_subscribe_published_file = 7319 // removed + // client_ucm_subscribe_published_file_response = 7320 // removed + client_ucm_enumerate_user_subscribed_files = 7321 + client_ucm_enumerate_user_subscribed_files_response = 7322 + // client_ucm_unsubscribe_published_file = 7323 // removed + // client_ucm_unsubscribe_published_file_response = 7324 // removed + client_ucm_update_published_file = 7325 + client_ucm_update_published_file_response = 7326 + ucm_update_published_file = 7327 + ucm_update_published_file_response = 7328 + ucm_delete_published_file = 7329 + ucm_delete_published_file_response = 7330 + ucm_update_published_file_stat = 7331 + // ucm_update_published_file_ban = 7332 // obsolete + // ucm_update_published_file_ban_response = 7333 // obsolete + // ucm_update_tagged_screenshot = 7334 // removed + // ucm_add_tagged_screenshot = 7335 // removed + // ucm_remove_tagged_screenshot = 7336 // removed + ucm_reload_published_file = 7337 + ucm_reload_user_file_list_caches = 7338 + ucm_published_file_reported = 7339 + // ucm_update_published_file_incompatible_status = 7340 // obsolete + ucm_published_file_preview_add = 7341 + ucm_published_file_preview_add_response = 7342 + ucm_published_file_preview_remove = 7343 + ucm_published_file_preview_remove_response = 7344 + // ucm_published_file_preview_change_sort_order = 7345 // removed + // ucm_published_file_preview_change_sort_order_response = 7346 // removed + client_ucm_published_file_subscribed = 7347 + client_ucm_published_file_unsubscribed = 7348 + ucm_published_file_subscribed = 7349 + ucm_published_file_unsubscribed = 7350 + ucm_publish_file = 7351 + ucm_publish_file_response = 7352 + ucm_published_file_child_add = 7353 + ucm_published_file_child_add_response = 7354 + ucm_published_file_child_remove = 7355 + ucm_published_file_child_remove_response = 7356 + // ucm_published_file_child_change_sort_order = 7357 // removed + // ucm_published_file_child_change_sort_order_response = 7358 // removed + ucm_published_file_parent_changed = 7359 + client_ucm_get_published_files_for_user = 7360 + client_ucm_get_published_files_for_user_response = 7361 + // ucm_get_published_files_for_user = 7362 // removed + // ucm_get_published_files_for_user_response = 7363 // removed + client_ucm_set_user_published_file_action = 7364 + client_ucm_set_user_published_file_action_response = 7365 + client_ucm_enumerate_published_files_by_user_action = 7366 + client_ucm_enumerate_published_files_by_user_action_response = 7367 + client_ucm_published_file_deleted = 7368 + ucm_get_user_subscribed_files = 7369 + ucm_get_user_subscribed_files_response = 7370 + ucm_fix_stats_published_file = 7371 + // ucm_delete_old_screenshot = 7372 // removed + // ucm_delete_old_screenshot_response = 7373 // removed + // ucm_delete_old_video = 7374 // removed + // ucm_delete_old_video_response = 7375 // removed + // ucm_update_old_screenshot_privacy = 7376 // removed + // ucm_update_old_screenshot_privacy_response = 7377 // removed + client_ucm_enumerate_user_subscribed_files_with_updates = 7378 + client_ucm_enumerate_user_subscribed_files_with_updates_response = 7379 + ucm_published_file_content_updated = 7380 + // ucm_published_file_updated = 7381 // obsolete "renamed to ClientUCMPublishedFileUpdated" + client_ucm_published_file_updated = 7381 + client_workshop_item_changes_request = 7382 + client_workshop_item_changes_response = 7383 + client_workshop_item_info_request = 7384 + client_workshop_item_info_response = 7385 + + // fs_base = 7500 + client_rich_presence_upload = 7501 + client_rich_presence_request = 7502 + client_rich_presence_info = 7503 + fs_rich_presence_request = 7504 + fs_rich_presence_response = 7505 + fs_compute_frenematrix = 7506 + fs_compute_frenematrix_response = 7507 + fs_play_status_notification = 7508 + // fs_publish_persona_status = 7509 // obsolete + fs_add_or_remove_follower = 7510 + fs_add_or_remove_follower_response = 7511 + fs_update_following_list = 7512 + fs_comment_notification = 7513 + fs_comment_notification_viewed = 7514 + client_fs_get_follower_count = 7515 + client_fs_get_follower_count_response = 7516 + client_fs_get_is_following = 7517 + client_fs_get_is_following_response = 7518 + client_fs_enumerate_following_list = 7519 + client_fs_enumerate_following_list_response = 7520 + fs_get_pending_notification_count = 7521 + fs_get_pending_notification_count_response = 7522 + // client_fs_offline_message_notification = 7523 // obsolete "Renamed to ClientChatOfflineMessageNotification" + // client_fs_request_offline_message_count = 7524 // obsolete "Renamed to ClientChatRequestOfflineMessageCount" + // client_fs_get_friend_message_history = 7525 // obsolete "Renamed to ClientChatGetFriendMessageHistory" + // client_fs_get_friend_message_history_response = 7526 // obsolete "Renamed to ClientChatGetFriendMessageHistoryResponse" + // client_fs_get_friend_message_history_for_offline_messages = 7527 // obsolete "Renamed to ClientChatGetFriendMessageHistoryForOfflineMessages" + client_chat_offline_message_notification = 7523 + client_chat_request_offline_message_count = 7524 + client_chat_get_friend_message_history = 7525 + client_chat_get_friend_message_history_response = 7526 + client_chat_get_friend_message_history_for_offline_messages = 7527 + client_fs_get_friends_steam_levels = 7528 + client_fs_get_friends_steam_levels_response = 7529 + // fs_request_friend_data = 7530 // obsolete "renamed to AMRequestFriendData" + am_request_friend_data = 7530 + + // drm_range2 = 7600 + ceg_version_set_enable_disable_request = 7600 + ceg_version_set_enable_disable_response = 7601 + ceg_prop_status_drms_request = 7602 + ceg_prop_status_drms_response = 7603 + ceg_whack_failure_report_request = 7604 + ceg_whack_failure_report_response = 7605 + drms_fetch_version_set = 7606 + drms_fetch_version_set_response = 7607 + + // econ_base = 7700 + econ_trading_initiate_trade_request = 7701 + econ_trading_initiate_trade_proposed = 7702 + econ_trading_initiate_trade_response = 7703 + econ_trading_initiate_trade_result = 7704 + econ_trading_start_session = 7705 + econ_trading_cancel_trade_request = 7706 + econ_flush_inventory_cache = 7707 + econ_flush_inventory_cache_response = 7708 + econ_cd_key_process_transaction = 7711 + econ_cd_key_process_transaction_response = 7712 + econ_get_error_logs = 7713 + econ_get_error_logs_response = 7714 + + // rm_range = 7800 + rm_test_verisign_otp = 7800 + rm_test_verisign_otp_response = 7801 + rm_delete_memcached_keys = 7803 + rm_remote_invoke = 7804 + bad_login_ip_list = 7805 + rm_msg_trace_add_trigger = 7806 + rm_msg_trace_remove_trigger = 7807 + rm_msg_trace_event = 7808 + + // ugs_base = 7900 + ugs_update_global_stats = 7900 + client_ugs_get_global_stats = 7901 + client_ugs_get_global_stats_response = 7902 + + // store_base = 8000 + // store_update_recommendation_count = 8000 // removed + + // umq_base = 8100 + umq_logon_request = 8100 + umq_logon_response = 8101 + umq_logoff_request = 8102 + umq_logoff_response = 8103 + umq_send_chat_message = 8104 + umq_incoming_chat_message = 8105 + umq_poll = 8106 + umq_poll_results = 8107 + umq2_am_client_msg_batch = 8108 + // umq_enqueue_mobile_sale_promotions = 8109 // removed + // umq_enqueue_mobile_announcements = 8110 // removed + + // workshop_base = 8200 + // workshop_accept_tos_request = 8200 // removed + // workshop_accept_tos_response = 8201 // removed + + // web_api_base = 8300 + web_api_validate_o_auth2_token = 8300 + web_api_validate_o_auth2_token_response = 8301 + // web_api_invalidate_tokens_for_account = 8302 // removed + web_api_register_gc_interfaces = 8303 + web_api_invalidate_o_auth_client_cache = 8304 + web_api_invalidate_o_auth_token_cache = 8305 + web_api_set_secrets = 8306 + + // backpack_base = 8400 + backpack_add_to_currency = 8401 + backpack_add_to_currency_response = 8402 + + // cre_base = 8500 + // cre_rank_by_trend = 8501 // removed + // cre_rank_by_trend_response = 8502 // removed + cre_item_vote_summary = 8503 + cre_item_vote_summary_response = 8504 + // cre_rank_by_vote = 8505 // removed + // cre_rank_by_vote_response = 8506 // removed + cre_update_user_published_item_vote = 8507 + cre_update_user_published_item_vote_response = 8508 + cre_get_user_published_item_vote_details = 8509 + cre_get_user_published_item_vote_details_response = 8510 + cre_enumerate_published_files = 8511 + cre_enumerate_published_files_response = 8512 + cre_published_file_vote_added = 8513 + + // secrets_base = 8600 + secrets_request_credential_pair = 8600 + secrets_credential_pair_response = 8601 + // secrets_request_server_identity = 8602 // removed + // secrets_server_identity_response = 8603 // removed + // secrets_update_server_identities = 8604 // removed + + // box_monitor_base = 8700 + box_monitor_report_request = 8700 + box_monitor_report_response = 8701 + + // logsink_base = 8800 + logsink_write_report = 8800 + + // pics_base = 8900 + client_pics_changes_since_request = 8901 + client_pics_changes_since_response = 8902 + client_pics_product_info_request = 8903 + client_pics_product_info_response = 8904 + client_pics_access_token_request = 8905 + client_pics_access_token_response = 8906 + + // worker_process = 9000 + worker_process_ping_request = 9000 + worker_process_ping_response = 9001 + worker_process_shutdown = 9002 + + // drm_worker_process = 9100 + drm_worker_process_drm_and_sign = 9100 + drm_worker_process_drm_and_sign_response = 9101 + drm_worker_process_steamworks_info_request = 9102 + drm_worker_process_steamworks_info_response = 9103 + drm_worker_process_install_drmdll_request = 9104 + drm_worker_process_install_drmdll_response = 9105 + drm_worker_process_secret_id_string_request = 9106 + drm_worker_process_secret_id_string_response = 9107 + // drm_worker_process_get_drm_guids_from_file_request = 9108 // removed + // drm_worker_process_get_drm_guids_from_file_response = 9109 // removed + drm_worker_process_install_processed_files_request = 9110 + drm_worker_process_install_processed_files_response = 9111 + drm_worker_process_examine_blob_request = 9112 + drm_worker_process_examine_blob_response = 9113 + drm_worker_process_describe_secret_request = 9114 + drm_worker_process_describe_secret_response = 9115 + drm_worker_process_backfill_original_request = 9116 + drm_worker_process_backfill_original_response = 9117 + drm_worker_process_validate_drmdll_request = 9118 + drm_worker_process_validate_drmdll_response = 9119 + drm_worker_process_validate_file_request = 9120 + drm_worker_process_validate_file_response = 9121 + drm_worker_process_split_and_install_request = 9122 + drm_worker_process_split_and_install_response = 9123 + drm_worker_process_get_blob_request = 9124 + drm_worker_process_get_blob_response = 9125 + drm_worker_process_evaluate_crash_request = 9126 + drm_worker_process_evaluate_crash_response = 9127 + drm_worker_process_analyze_file_request = 9128 + drm_worker_process_analyze_file_response = 9129 + drm_worker_process_unpack_blob_request = 9130 + drm_worker_process_unpack_blob_response = 9131 + drm_worker_process_install_all_request = 9132 + drm_worker_process_install_all_response = 9133 + + // test_worker_process = 9200 + test_worker_process_load_unload_module_request = 9200 + test_worker_process_load_unload_module_response = 9201 + test_worker_process_service_module_call_request = 9202 + test_worker_process_service_module_call_response = 9203 + + // quest_server_base = 9300 + + client_get_emoticon_list = 9330 + client_emoticon_list = 9331 + + // client_shared_library_base = 9400 // removed "renamed to SLCBase" + // slc_base = 9400 + slc_user_session_status = 9400 + slc_request_user_session_status = 9401 + slc_shared_licenses_lock_status = 9402 + // client_shared_licenses_lock_status = 9403 // removed + // client_shared_licenses_stop_playing = 9404 // removed + client_shared_library_lock_status = 9405 + client_shared_library_stop_playing = 9406 + slc_owner_library_changed = 9407 + slc_shared_library_changed = 9408 + + remote_client_base = 9500 + // remote_client_auth = 9500 // obsolete + // remote_client_auth_response = 9501 // obsolete + remote_client_app_status = 9502 + remote_client_start_stream = 9503 + remote_client_start_stream_response = 9504 + remote_client_ping = 9505 + remote_client_ping_response = 9506 + client_unlock_streaming = 9507 + client_unlock_streaming_response = 9508 + remote_client_accept_eula = 9509 + remote_client_get_controller_config = 9510 + // remote_client_get_controller_config_resposne = 9511 // obsolete "renamed to RemoteClientGetControllerConfigResponse" + remote_client_get_controller_config_response = 9511 + remote_client_streaming_enabled = 9512 + client_unlock_hevc = 9513 + client_unlock_hevc_response = 9514 + remote_client_status_request = 9515 + remote_client_status_response = 9516 + + // client_concurrent_sessions_base = 9600 + client_playing_session_state = 9600 + client_kick_playing_session = 9601 + + // client_broadcast_base = 9700 + client_broadcast_init = 9700 + client_broadcast_frames = 9701 + client_broadcast_disconnect = 9702 + client_broadcast_screenshot = 9703 + client_broadcast_upload_config = 9704 + + // base_client3 = 9800 + client_voice_call_pre_authorize = 9800 + client_voice_call_pre_authorize_response = 9801 + client_server_timestamp_request = 9802 + client_server_timestamp_response = 9803 + + // client_lanp2_p_base = 9900 + client_lanp2_p_request_chunk = 9900 + client_lanp2_p_request_chunk_response = 9901 + client_lanp2_p_max = 9999 + + // base_watchdog_server = 10000 + notify_watchdog = 10000 + + // client_site_license_base = 10100 + client_site_license_site_info_notification = 10100 + client_site_license_checkout = 10101 + client_site_license_checkout_response = 10102 + client_site_license_get_available_seats = 10103 + client_site_license_get_available_seats_response = 10104 + client_site_license_get_content_cache_info = 10105 + client_site_license_get_content_cache_info_response = 10106 + + // base_chat_server = 12000 + chat_server_get_pending_notification_count = 12000 + chat_server_get_pending_notification_count_response = 12001 + + // base_secret_server = 12100 + server_secret_changed = 12100 +} + +pub fn (m Msg) make_proto() u32 { + return msg_make_proto(m) +} + +const ( + proto_mask = 0x80000000 +) + +fn msg_is_proto(msg u32) bool { + return msg & proto_mask == proto_mask +} + +fn msg_make_proto(msg Msg) u32 { + return u32(msg) | proto_mask +} + +fn raw_msg(msg u32) Msg { + return Msg(msg & ~proto_mask) +} \ No newline at end of file diff --git a/msghandler.v b/msghandler.v new file mode 100644 index 0000000..920833b --- /dev/null +++ b/msghandler.v @@ -0,0 +1,6 @@ +module vapor + +interface MsgHandler { + initialise(mut s SteamClient)? + handle_msg(m Message)? +} diff --git a/pack_helper.h b/pack_helper.h new file mode 100644 index 0000000..188fb91 --- /dev/null +++ b/pack_helper.h @@ -0,0 +1 @@ +#pragma pack(4) \ No newline at end of file diff --git a/packable.v b/packable.v new file mode 100644 index 0000000..df87d5e --- /dev/null +++ b/packable.v @@ -0,0 +1,5 @@ +module vapor + +interface Packable { + pack() []byte +} \ No newline at end of file diff --git a/proto/content_manifest_pb.v b/proto/content_manifest_pb.v new file mode 100644 index 0000000..18c2422 --- /dev/null +++ b/proto/content_manifest_pb.v @@ -0,0 +1,778 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +[_allow_multiple_values] +enum EContentDeltaChunkDataLocation { +k_econtentdeltachunkdatalocationinprotobuf = 0 +k_econtentdeltachunkdatalocationafterprotobuf = 1 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_econtentdeltachunkdatalocation(e EContentDeltaChunkDataLocation, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_econtentdeltachunkdatalocation(buf []byte, tag_wiretype vproto.WireType) ?(int, EContentDeltaChunkDataLocation) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EContentDeltaChunkDataLocation(v) +} +pub struct ContentManifestPayloadFileMappingChunkData { +mut: +unknown_fields []vproto.UnknownField +pub mut: +sha []byte +has_sha bool +crc u32 +has_crc bool +offset u64 +has_offset bool +cb_original u32 +has_cb_original bool +cb_compressed u32 +has_cb_compressed bool +} +pub fn (o &ContentManifestPayloadFileMappingChunkData) pack() []byte { +mut res := []byte{} +if o.has_sha { +res << vproto.pack_bytes_field(o.sha, 1) +} + +if o.has_crc { +res << vproto.pack_32bit_field(o.crc, 2) +} + +if o.has_offset { +res << vproto.pack_uint64_field(o.offset, 3) +} + +if o.has_cb_original { +res << vproto.pack_uint32_field(o.cb_original, 4) +} + +if o.has_cb_compressed { +res << vproto.pack_uint32_field(o.cb_compressed, 5) +} + +return res +} + +pub fn contentmanifestpayloadfilemappingchunkdata_unpack(buf []byte) ?ContentManifestPayloadFileMappingChunkData { +mut res := ContentManifestPayloadFileMappingChunkData{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_sha = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha = v +i = ii +} + +2 { +res.has_crc = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.crc = v +i = ii +} + +3 { +res.has_offset = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.offset = v +i = ii +} + +4 { +res.has_cb_original = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cb_original = v +i = ii +} + +5 { +res.has_cb_compressed = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cb_compressed = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_contentmanifestpayloadfilemappingchunkdata() ContentManifestPayloadFileMappingChunkData { +return ContentManifestPayloadFileMappingChunkData{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_contentmanifestpayloadfilemappingchunkdata(o ContentManifestPayloadFileMappingChunkData, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_contentmanifestpayloadfilemappingchunkdata(buf []byte, tag_wiretype vproto.WireType) ?(int, ContentManifestPayloadFileMappingChunkData) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := contentmanifestpayloadfilemappingchunkdata_unpack(v)? +return i, unpacked +} +pub struct ContentManifestPayloadFileMapping { +mut: +unknown_fields []vproto.UnknownField +pub mut: +filename string +has_filename bool +size u64 +has_size bool +flags u32 +has_flags bool +sha_filename []byte +has_sha_filename bool +sha_content []byte +has_sha_content bool +chunks []ContentManifestPayloadFileMappingChunkData +linktarget string +has_linktarget bool +} +pub fn (o &ContentManifestPayloadFileMapping) pack() []byte { +mut res := []byte{} +if o.has_filename { +res << vproto.pack_string_field(o.filename, 1) +} + +if o.has_size { +res << vproto.pack_uint64_field(o.size, 2) +} + +if o.has_flags { +res << vproto.pack_uint32_field(o.flags, 3) +} + +if o.has_sha_filename { +res << vproto.pack_bytes_field(o.sha_filename, 4) +} + +if o.has_sha_content { +res << vproto.pack_bytes_field(o.sha_content, 5) +} + +// [packed=false] +for _, x in o.chunks { +res << zzz_vproto_internal_pack_contentmanifestpayloadfilemappingchunkdata(x, 6) +} + +if o.has_linktarget { +res << vproto.pack_string_field(o.linktarget, 7) +} + +return res +} + +pub fn contentmanifestpayloadfilemapping_unpack(buf []byte) ?ContentManifestPayloadFileMapping { +mut res := ContentManifestPayloadFileMapping{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.filename = v +i = ii +} + +2 { +res.has_size = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.size = v +i = ii +} + +3 { +res.has_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.flags = v +i = ii +} + +4 { +res.has_sha_filename = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha_filename = v +i = ii +} + +5 { +res.has_sha_content = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha_content = v +i = ii +} + +6 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_contentmanifestpayloadfilemappingchunkdata(cur_buf, tag_wiretype.wire_type)? +res.chunks << v +i = ii +} + +7 { +res.has_linktarget = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.linktarget = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_contentmanifestpayloadfilemapping() ContentManifestPayloadFileMapping { +return ContentManifestPayloadFileMapping{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_contentmanifestpayloadfilemapping(o ContentManifestPayloadFileMapping, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_contentmanifestpayloadfilemapping(buf []byte, tag_wiretype vproto.WireType) ?(int, ContentManifestPayloadFileMapping) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := contentmanifestpayloadfilemapping_unpack(v)? +return i, unpacked +} +pub struct ContentManifestPayload { +mut: +unknown_fields []vproto.UnknownField +pub mut: +mappings []ContentManifestPayloadFileMapping +} +pub fn (o &ContentManifestPayload) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.mappings { +res << zzz_vproto_internal_pack_contentmanifestpayloadfilemapping(x, 1) +} + +return res +} + +pub fn contentmanifestpayload_unpack(buf []byte) ?ContentManifestPayload { +mut res := ContentManifestPayload{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_contentmanifestpayloadfilemapping(cur_buf, tag_wiretype.wire_type)? +res.mappings << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_contentmanifestpayload() ContentManifestPayload { +return ContentManifestPayload{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_contentmanifestpayload(o ContentManifestPayload, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_contentmanifestpayload(buf []byte, tag_wiretype vproto.WireType) ?(int, ContentManifestPayload) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := contentmanifestpayload_unpack(v)? +return i, unpacked +} +pub struct ContentManifestMetadata { +mut: +unknown_fields []vproto.UnknownField +pub mut: +depot_id u32 +has_depot_id bool +gid_manifest u64 +has_gid_manifest bool +creation_time u32 +has_creation_time bool +filenames_encrypted bool +has_filenames_encrypted bool +cb_disk_original u64 +has_cb_disk_original bool +cb_disk_compressed u64 +has_cb_disk_compressed bool +unique_chunks u32 +has_unique_chunks bool +crc_encrypted u32 +has_crc_encrypted bool +crc_clear u32 +has_crc_clear bool +} +pub fn (o &ContentManifestMetadata) pack() []byte { +mut res := []byte{} +if o.has_depot_id { +res << vproto.pack_uint32_field(o.depot_id, 1) +} + +if o.has_gid_manifest { +res << vproto.pack_uint64_field(o.gid_manifest, 2) +} + +if o.has_creation_time { +res << vproto.pack_uint32_field(o.creation_time, 3) +} + +if o.has_filenames_encrypted { +res << vproto.pack_bool_field(o.filenames_encrypted, 4) +} + +if o.has_cb_disk_original { +res << vproto.pack_uint64_field(o.cb_disk_original, 5) +} + +if o.has_cb_disk_compressed { +res << vproto.pack_uint64_field(o.cb_disk_compressed, 6) +} + +if o.has_unique_chunks { +res << vproto.pack_uint32_field(o.unique_chunks, 7) +} + +if o.has_crc_encrypted { +res << vproto.pack_uint32_field(o.crc_encrypted, 8) +} + +if o.has_crc_clear { +res << vproto.pack_uint32_field(o.crc_clear, 9) +} + +return res +} + +pub fn contentmanifestmetadata_unpack(buf []byte) ?ContentManifestMetadata { +mut res := ContentManifestMetadata{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_depot_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.depot_id = v +i = ii +} + +2 { +res.has_gid_manifest = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.gid_manifest = v +i = ii +} + +3 { +res.has_creation_time = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.creation_time = v +i = ii +} + +4 { +res.has_filenames_encrypted = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.filenames_encrypted = v +i = ii +} + +5 { +res.has_cb_disk_original = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.cb_disk_original = v +i = ii +} + +6 { +res.has_cb_disk_compressed = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.cb_disk_compressed = v +i = ii +} + +7 { +res.has_unique_chunks = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.unique_chunks = v +i = ii +} + +8 { +res.has_crc_encrypted = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.crc_encrypted = v +i = ii +} + +9 { +res.has_crc_clear = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.crc_clear = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_contentmanifestmetadata() ContentManifestMetadata { +return ContentManifestMetadata{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_contentmanifestmetadata(o ContentManifestMetadata, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_contentmanifestmetadata(buf []byte, tag_wiretype vproto.WireType) ?(int, ContentManifestMetadata) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := contentmanifestmetadata_unpack(v)? +return i, unpacked +} +pub struct ContentManifestSignature { +mut: +unknown_fields []vproto.UnknownField +pub mut: +signature []byte +has_signature bool +} +pub fn (o &ContentManifestSignature) pack() []byte { +mut res := []byte{} +if o.has_signature { +res << vproto.pack_bytes_field(o.signature, 1) +} + +return res +} + +pub fn contentmanifestsignature_unpack(buf []byte) ?ContentManifestSignature { +mut res := ContentManifestSignature{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_signature = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.signature = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_contentmanifestsignature() ContentManifestSignature { +return ContentManifestSignature{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_contentmanifestsignature(o ContentManifestSignature, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_contentmanifestsignature(buf []byte, tag_wiretype vproto.WireType) ?(int, ContentManifestSignature) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := contentmanifestsignature_unpack(v)? +return i, unpacked +} +pub struct ContentDeltaChunksDeltaChunk { +mut: +unknown_fields []vproto.UnknownField +pub mut: +sha_source []byte +has_sha_source bool +sha_target []byte +has_sha_target bool +size_original u32 +has_size_original bool +patch_method u32 +has_patch_method bool +chunk []byte +has_chunk bool +size_delta u32 +has_size_delta bool +} +pub fn (o &ContentDeltaChunksDeltaChunk) pack() []byte { +mut res := []byte{} +if o.has_sha_source { +res << vproto.pack_bytes_field(o.sha_source, 1) +} + +if o.has_sha_target { +res << vproto.pack_bytes_field(o.sha_target, 2) +} + +if o.has_size_original { +res << vproto.pack_uint32_field(o.size_original, 3) +} + +if o.has_patch_method { +res << vproto.pack_uint32_field(o.patch_method, 4) +} + +if o.has_chunk { +res << vproto.pack_bytes_field(o.chunk, 5) +} + +if o.has_size_delta { +res << vproto.pack_uint32_field(o.size_delta, 6) +} + +return res +} + +pub fn contentdeltachunksdeltachunk_unpack(buf []byte) ?ContentDeltaChunksDeltaChunk { +mut res := ContentDeltaChunksDeltaChunk{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_sha_source = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha_source = v +i = ii +} + +2 { +res.has_sha_target = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha_target = v +i = ii +} + +3 { +res.has_size_original = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.size_original = v +i = ii +} + +4 { +res.has_patch_method = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.patch_method = v +i = ii +} + +5 { +res.has_chunk = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.chunk = v +i = ii +} + +6 { +res.has_size_delta = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.size_delta = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_contentdeltachunksdeltachunk() ContentDeltaChunksDeltaChunk { +return ContentDeltaChunksDeltaChunk{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_contentdeltachunksdeltachunk(o ContentDeltaChunksDeltaChunk, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_contentdeltachunksdeltachunk(buf []byte, tag_wiretype vproto.WireType) ?(int, ContentDeltaChunksDeltaChunk) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := contentdeltachunksdeltachunk_unpack(v)? +return i, unpacked +} +pub struct ContentDeltaChunks { +mut: +unknown_fields []vproto.UnknownField +pub mut: +depot_id u32 +has_depot_id bool +manifest_id_source u64 +has_manifest_id_source bool +manifest_id_target u64 +has_manifest_id_target bool +deltachunks []ContentDeltaChunksDeltaChunk +chunk_data_location EContentDeltaChunkDataLocation +has_chunk_data_location bool +} +pub fn (o &ContentDeltaChunks) pack() []byte { +mut res := []byte{} +if o.has_depot_id { +res << vproto.pack_uint32_field(o.depot_id, 1) +} + +if o.has_manifest_id_source { +res << vproto.pack_uint64_field(o.manifest_id_source, 2) +} + +if o.has_manifest_id_target { +res << vproto.pack_uint64_field(o.manifest_id_target, 3) +} + +// [packed=false] +for _, x in o.deltachunks { +res << zzz_vproto_internal_pack_contentdeltachunksdeltachunk(x, 4) +} + +if o.has_chunk_data_location { +res << zzz_vproto_internal_pack_econtentdeltachunkdatalocation(o.chunk_data_location, 5) +} + +return res +} + +pub fn contentdeltachunks_unpack(buf []byte) ?ContentDeltaChunks { +mut res := ContentDeltaChunks{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_depot_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.depot_id = v +i = ii +} + +2 { +res.has_manifest_id_source = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.manifest_id_source = v +i = ii +} + +3 { +res.has_manifest_id_target = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.manifest_id_target = v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_contentdeltachunksdeltachunk(cur_buf, tag_wiretype.wire_type)? +res.deltachunks << v +i = ii +} + +5 { +res.has_chunk_data_location = true +ii, v := zzz_vproto_internal_unpack_econtentdeltachunkdatalocation(cur_buf, tag_wiretype.wire_type)? +res.chunk_data_location = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_contentdeltachunks() ContentDeltaChunks { +return ContentDeltaChunks{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_contentdeltachunks(o ContentDeltaChunks, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_contentdeltachunks(buf []byte, tag_wiretype vproto.WireType) ?(int, ContentDeltaChunks) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := contentdeltachunks_unpack(v)? +return i, unpacked +} diff --git a/proto/encrypted_app_ticket_pb.v b/proto/encrypted_app_ticket_pb.v new file mode 100644 index 0000000..a300aae --- /dev/null +++ b/proto/encrypted_app_ticket_pb.v @@ -0,0 +1,117 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct EncryptedAppTicket { +mut: +unknown_fields []vproto.UnknownField +pub mut: +ticket_version_no u32 +has_ticket_version_no bool +crc_encryptedticket u32 +has_crc_encryptedticket bool +cb_encrypteduserdata u32 +has_cb_encrypteduserdata bool +cb_encrypted_appownershipticket u32 +has_cb_encrypted_appownershipticket bool +encrypted_ticket []byte +has_encrypted_ticket bool +} +pub fn (o &EncryptedAppTicket) pack() []byte { +mut res := []byte{} +if o.has_ticket_version_no { +res << vproto.pack_uint32_field(o.ticket_version_no, 1) +} + +if o.has_crc_encryptedticket { +res << vproto.pack_uint32_field(o.crc_encryptedticket, 2) +} + +if o.has_cb_encrypteduserdata { +res << vproto.pack_uint32_field(o.cb_encrypteduserdata, 3) +} + +if o.has_cb_encrypted_appownershipticket { +res << vproto.pack_uint32_field(o.cb_encrypted_appownershipticket, 4) +} + +if o.has_encrypted_ticket { +res << vproto.pack_bytes_field(o.encrypted_ticket, 5) +} + +return res +} + +pub fn encryptedappticket_unpack(buf []byte) ?EncryptedAppTicket { +mut res := EncryptedAppTicket{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_ticket_version_no = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ticket_version_no = v +i = ii +} + +2 { +res.has_crc_encryptedticket = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.crc_encryptedticket = v +i = ii +} + +3 { +res.has_cb_encrypteduserdata = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cb_encrypteduserdata = v +i = ii +} + +4 { +res.has_cb_encrypted_appownershipticket = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cb_encrypted_appownershipticket = v +i = ii +} + +5 { +res.has_encrypted_ticket = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.encrypted_ticket = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_encryptedappticket() EncryptedAppTicket { +return EncryptedAppTicket{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_encryptedappticket(o EncryptedAppTicket, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_encryptedappticket(buf []byte, tag_wiretype vproto.WireType) ?(int, EncryptedAppTicket) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := encryptedappticket_unpack(v)? +return i, unpacked +} diff --git a/proto/enums_clientserver_pb.v b/proto/enums_clientserver_pb.v new file mode 100644 index 0000000..f5bac01 --- /dev/null +++ b/proto/enums_clientserver_pb.v @@ -0,0 +1,1582 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +[_allow_multiple_values] +enum EMsg { +k_emsginvalid = 0 +k_emsgmulti = 1 +k_emsgprotobufwrapped = 2 +k_emsgbasegeneral = 100 +k_emsggenericreply = 100 +k_emsgdestjobfailed = 113 +k_emsgalert = 115 +k_emsgscidrequest = 120 +k_emsgscidresponse = 121 +k_emsgjobheartbeat = 123 +k_emsghubconnect = 124 +k_emsgsubscribe = 126 +k_emroutemessage = 127 +k_emsgwgrequest = 130 +k_emsgwgresponse = 131 +k_emsgkeepalive = 132 +k_emsgwebapijobrequest = 133 +k_emsgwebapijobresponse = 134 +k_emsgclientsessionstart = 135 +k_emsgclientsessionend = 136 +k_emsgclientsessionupdate = 137 +k_emsgstatsdeprecated = 138 +k_emsgping = 139 +k_emsgpingresponse = 140 +k_emsgstats = 141 +k_emsgrequestfullstatsblock = 142 +k_emsgloaddbocacheitem = 143 +k_emsgloaddbocacheitemresponse = 144 +k_emsginvalidatedbocacheitems = 145 +k_emsgservicemethod = 146 +k_emsgservicemethodresponse = 147 +k_emsgclientpackageversions = 148 +k_emsgtimestamprequest = 149 +k_emsgtimestampresponse = 150 +k_emsgservicemethodcallfromclient = 151 +k_emsgservicemethodsendtoclient = 152 +k_emsgbaseshell = 200 +k_emsgassignsysid = 200 +k_emsgexit = 201 +k_emsgdirrequest = 202 +k_emsgdirresponse = 203 +k_emsgziprequest = 204 +k_emsgzipresponse = 205 +k_emsgupdaterecordresponse = 215 +k_emsgupdatecreditcardrequest = 221 +k_emsgupdateuserbanresponse = 225 +k_emsgpreparetoexit = 226 +k_emsgcontentdescriptionupdate = 227 +k_emsgtestresetserver = 228 +k_emsguniversechanged = 229 +k_emsgshellconfiginfoupdate = 230 +k_emsgrequestwindowseventlogentries = 233 +k_emsgprovidewindowseventlogentries = 234 +k_emsgshellsearchlogs = 235 +k_emsgshellsearchlogsresponse = 236 +k_emsgshellcheckwindowsupdates = 237 +k_emsgshellcheckwindowsupdatesresponse = 238 +k_emsgtestflushdelayedsql = 240 +k_emsgtestflushdelayedsqlresponse = 241 +k_emsgensureexecutescheduledtask_test = 242 +k_emsgensureexecutescheduledtaskresponse_test = 243 +k_emsgupdatescheduledtaskenablestate_test = 244 +k_emsgupdatescheduledtaskenablestateresponse_test = 245 +k_emsgcontentdescriptiondeltaupdate = 246 +k_emsgbasegm = 300 +k_emsgheartbeat = 300 +k_emsgshellfailed = 301 +k_emsgexitshells = 307 +k_emsgexitshell = 308 +k_emsggracefulexitshell = 309 +k_emsglicenseprocessingcomplete = 316 +k_emsgsettestflag = 317 +k_emsgqueuedemailscomplete = 318 +k_emsggmreportphperror = 319 +k_emsggmdrmsync = 320 +k_emsgphysicalboxinventory = 321 +k_emsgupdateconfigfile = 322 +k_emsgtestinitdb = 323 +k_emsggmwriteconfigtosql = 324 +k_emsggmloadactivationcodes = 325 +k_emsggmqueueforfbs = 326 +k_emsggmschemaconversionresults = 327 +k_emsggmwriteshellfailuretosql = 329 +k_emsggmwritestatstosos = 330 +k_emsggmgetservicemethodrouting = 331 +k_emsggmgetservicemethodroutingresponse = 332 +k_emsggmtestnextbuildschemaconversion = 334 +k_emsggmtestnextbuildschemaconversionresponse = 335 +k_emsgexpectshellrestart = 336 +k_emsghotfixprogress = 337 +k_emsgbaseais = 400 +k_emsgaisrequestcontentdescription = 402 +k_emsgaisupdateappinfo = 403 +k_emsgaisgetpackagechangenumber = 405 +k_emsgaisgetpackagechangenumberresponse = 406 +k_emsgaigetappgcflags = 423 +k_emsgaigetappgcflagsresponse = 424 +k_emsgaigetapplist = 425 +k_emsgaigetapplistresponse = 426 +k_emsgaisgetcoupondefinition = 429 +k_emsgaisgetcoupondefinitionresponse = 430 +k_emsgaisupdateslavecontentdescription = 431 +k_emsgaisupdateslavecontentdescriptionresponse = 432 +k_emsgaistestenablegc = 433 +k_emsgbaseam = 500 +k_emsgamupdateuserbanrequest = 504 +k_emsgamaddlicense = 505 +k_emsgamsendsystemimtouser = 508 +k_emsgamextendlicense = 509 +k_emsgamaddminutestolicense = 510 +k_emsgamcancellicense = 511 +k_emsgaminitpurchase = 512 +k_emsgampurchaseresponse = 513 +k_emsgamgetfinalprice = 514 +k_emsgamgetfinalpriceresponse = 515 +k_emsgamgetlegacygamekey = 516 +k_emsgamgetlegacygamekeyresponse = 517 +k_emsgamfindhungtransactions = 518 +k_emsgamsetaccounttrustedrequest = 519 +k_emsgamcancelpurchase = 522 +k_emsgamnewchallenge = 523 +k_emsgamloadoemtickets = 524 +k_emsgamfixpendingpurchase = 525 +k_emsgamfixpendingpurchaseresponse = 526 +k_emsgamisuserbanned = 527 +k_emsgamregisterkey = 528 +k_emsgamloadactivationcodes = 529 +k_emsgamloadactivationcodesresponse = 530 +k_emsgamlookupkeyresponse = 531 +k_emsgamlookupkey = 532 +k_emsgamchatcleanup = 533 +k_emsgamclancleanup = 534 +k_emsgamfixpendingrefund = 535 +k_emsgamreversechargeback = 536 +k_emsgamreversechargebackresponse = 537 +k_emsgamclancleanuplist = 538 +k_emsgamgetlicenses = 539 +k_emsgamgetlicensesresponse = 540 +k_emsgamsendcartrepurchase = 541 +k_emsgamsendcartrepurchaseresponse = 542 +k_emsgallowusertoplayquery = 550 +k_emsgallowusertoplayresponse = 551 +k_emsgamverfiyuser = 552 +k_emsgamclientnotplaying = 553 +k_emsgamclientrequestfriendship = 554 +k_emsgamrelaypublishstatus = 555 +k_emsgaminitpurchaseresponse = 560 +k_emsgamrevokepurchaseresponse = 561 +k_emsgamrefreshguestpasses = 563 +k_emsgamgrantguestpasses = 566 +k_emsgamclandataupdated = 567 +k_emsgamreloadaccount = 568 +k_emsgamclientchatmsgrelay = 569 +k_emsgamchatmulti = 570 +k_emsgamclientchatinviterelay = 571 +k_emsgamchatinvite = 572 +k_emsgamclientjoinchatrelay = 573 +k_emsgamclientchatmemberinforelay = 574 +k_emsgampublishchatmemberinfo = 575 +k_emsgamclientacceptfriendinvite = 576 +k_emsgamchatenter = 577 +k_emsgamclientpublishremovalfromsource = 578 +k_emsgamchatactionresult = 579 +k_emsgamfindaccounts = 580 +k_emsgamfindaccountsresponse = 581 +k_emsgamrequestaccountdata = 582 +k_emsgamrequestaccountdataresponse = 583 +k_emsgamsetaccountflags = 584 +k_emsgamcreateclan = 586 +k_emsgamcreateclanresponse = 587 +k_emsgamgetclandetails = 588 +k_emsgamgetclandetailsresponse = 589 +k_emsgamsetpersonaname = 590 +k_emsgamsetavatar = 591 +k_emsgamauthenticateuser = 592 +k_emsgamauthenticateuserresponse = 593 +k_emsgamp2pintroducermessage = 596 +k_emsgclientchataction = 597 +k_emsgamclientchatactionrelay = 598 +k_emsgbasevs = 600 +k_emsgreqchallenge = 600 +k_emsgvacresponse = 601 +k_emsgreqchallengetest = 602 +k_emsgvsmarkcheat = 604 +k_emsgvsaddcheat = 605 +k_emsgvspurgecodemoddb = 606 +k_emsgvsgetchallengeresults = 607 +k_emsgvschallengeresulttext = 608 +k_emsgvsreportlingerer = 609 +k_emsgvsrequestmanagedchallenge = 610 +k_emsgvsloaddbfinished = 611 +k_emsgbasedrms = 625 +k_emsgdrmbuildblobrequest = 628 +k_emsgdrmbuildblobresponse = 629 +k_emsgdrmresolveguidrequest = 630 +k_emsgdrmresolveguidresponse = 631 +k_emsgdrmvariabilityreport = 633 +k_emsgdrmvariabilityreportresponse = 634 +k_emsgdrmstabilityreport = 635 +k_emsgdrmstabilityreportresponse = 636 +k_emsgdrmdetailsreportrequest = 637 +k_emsgdrmdetailsreportresponse = 638 +k_emsgdrmprocessfile = 639 +k_emsgdrmadminupdate = 640 +k_emsgdrmadminupdateresponse = 641 +k_emsgdrmsync = 642 +k_emsgdrmsyncresponse = 643 +k_emsgdrmprocessfileresponse = 644 +k_emsgdrmemptyguidcache = 645 +k_emsgdrmemptyguidcacheresponse = 646 +k_emsgbasecs = 650 +k_emsgbaseclient = 700 +k_emsgclientlogon_deprecated = 701 +k_emsgclientanonlogon_deprecated = 702 +k_emsgclientheartbeat = 703 +k_emsgclientvacresponse = 704 +k_emsgclientgamesplayed_obsolete = 705 +k_emsgclientlogoff = 706 +k_emsgclientnoudpconnectivity = 707 +k_emsgclientconnectionstats = 710 +k_emsgclientpingresponse = 712 +k_emsgclientremovefriend = 714 +k_emsgclientgamesplayednodatablob = 715 +k_emsgclientchangestatus = 716 +k_emsgclientvacstatusresponse = 717 +k_emsgclientfriendmsg = 718 +k_emsgclientgameconnect_obsolete = 719 +k_emsgclientgamesplayed2_obsolete = 720 +k_emsgclientgameended_obsolete = 721 +k_emsgclientsystemim = 726 +k_emsgclientsystemimack = 727 +k_emsgclientgetlicenses = 728 +k_emsgclientgetlegacygamekey = 730 +k_emsgclientcontentserverlogon_deprecated = 731 +k_emsgclientackvacban2 = 732 +k_emsgclientgetpurchasereceipts = 736 +k_emsgclientgamesplayed3_obsolete = 738 +k_emsgclientackguestpass = 740 +k_emsgclientredeemguestpass = 741 +k_emsgclientgamesplayed = 742 +k_emsgclientregisterkey = 743 +k_emsgclientinviteusertoclan = 744 +k_emsgclientacknowledgeclaninvite = 745 +k_emsgclientpurchasewithmachineid = 746 +k_emsgclientappusageevent = 747 +k_emsgclientlogonresponse = 751 +k_emsgclientsetheartbeatrate = 755 +k_emsgclientnotloggedondeprecated = 756 +k_emsgclientloggedoff = 757 +k_emsggsapprove = 758 +k_emsggsdeny = 759 +k_emsggskick = 760 +k_emsgclientcreateacctresponse = 761 +k_emsgclientpurchaseresponse = 763 +k_emsgclientping = 764 +k_emsgclientnop = 765 +k_emsgclientpersonastate = 766 +k_emsgclientfriendslist = 767 +k_emsgclientaccountinfo = 768 +k_emsgclientnewsupdate = 771 +k_emsgclientgameconnectdeny = 773 +k_emsggsstatusreply = 774 +k_emsgclientgameconnecttokens = 779 +k_emsgclientlicenselist = 780 +k_emsgclientvacbanstatus = 782 +k_emsgclientcmlist = 783 +k_emsgclientencryptpct = 784 +k_emsgclientgetlegacygamekeyresponse = 785 +k_emsgclientaddfriend = 791 +k_emsgclientaddfriendresponse = 792 +k_emsgclientackguestpassresponse = 796 +k_emsgclientredeemguestpassresponse = 797 +k_emsgclientupdateguestpasseslist = 798 +k_emsgclientchatmsg = 799 +k_emsgclientchatinvite = 800 +k_emsgclientjoinchat = 801 +k_emsgclientchatmemberinfo = 802 +k_emsgclientlogonwithcredentials_deprecated = 803 +k_emsgclientpasswordchangeresponse = 805 +k_emsgclientchatenter = 807 +k_emsgclientfriendremovedfromsource = 808 +k_emsgclientcreatechat = 809 +k_emsgclientcreatechatresponse = 810 +k_emsgclientp2pintroducermessage = 813 +k_emsgclientchatactionresult = 814 +k_emsgclientrequestfrienddata = 815 +k_emsgclientgetuserstats = 818 +k_emsgclientgetuserstatsresponse = 819 +k_emsgclientstoreuserstats = 820 +k_emsgclientstoreuserstatsresponse = 821 +k_emsgclientclanstate = 822 +k_emsgclientservicemodule = 830 +k_emsgclientservicecall = 831 +k_emsgclientservicecallresponse = 832 +k_emsgclientnattraversalstatevent = 839 +k_emsgclientsteamusageevent = 842 +k_emsgclientcheckpassword = 845 +k_emsgclientresetpassword = 846 +k_emsgclientcheckpasswordresponse = 848 +k_emsgclientresetpasswordresponse = 849 +k_emsgclientsessiontoken = 850 +k_emsgclientdrmproblemreport = 851 +k_emsgclientsetignorefriend = 855 +k_emsgclientsetignorefriendresponse = 856 +k_emsgclientgetappownershipticket = 857 +k_emsgclientgetappownershipticketresponse = 858 +k_emsgclientgetlobbylistresponse = 860 +k_emsgclientserverlist = 880 +k_emsgclientdrmblobrequest = 896 +k_emsgclientdrmblobresponse = 897 +k_emsgbasegameserver = 900 +k_emsggsdisconnectnotice = 901 +k_emsggsstatus = 903 +k_emsggsuserplaying = 905 +k_emsggsstatus2 = 906 +k_emsggsstatusupdate_unused = 907 +k_emsggsservertype = 908 +k_emsggsplayerlist = 909 +k_emsggsgetuserachievementstatus = 910 +k_emsggsgetuserachievementstatusresponse = 911 +k_emsggsgetplaystats = 918 +k_emsggsgetplaystatsresponse = 919 +k_emsggsgetusergroupstatus = 920 +k_emsgamgetusergroupstatus = 921 +k_emsgamgetusergroupstatusresponse = 922 +k_emsggsgetusergroupstatusresponse = 923 +k_emsggsgetreputation = 936 +k_emsggsgetreputationresponse = 937 +k_emsggsassociatewithclan = 938 +k_emsggsassociatewithclanresponse = 939 +k_emsggscomputenewplayercompatibility = 940 +k_emsggscomputenewplayercompatibilityresponse = 941 +k_emsgbaseadmin = 1000 +k_emsgadmincmd = 1000 +k_emsgadmincmdresponse = 1004 +k_emsgadminloglistenrequest = 1005 +k_emsgadminlogevent = 1006 +k_emsguniversedata = 1010 +k_emsgadminspew = 1019 +k_emsgadminconsoletitle = 1020 +k_emsgadmingcspew = 1023 +k_emsgadmingccommand = 1024 +k_emsgadmingcgetcommandlist = 1025 +k_emsgadmingcgetcommandlistresponse = 1026 +k_emsgfbsconnectiondata = 1027 +k_emsgadminmsgspew = 1028 +k_emsgbasefbs = 1100 +k_emsgfbsreqversion = 1100 +k_emsgfbsversioninfo = 1101 +k_emsgfbsforcerefresh = 1102 +k_emsgfbsforcebounce = 1103 +k_emsgfbsdeploypackage = 1104 +k_emsgfbsdeployresponse = 1105 +k_emsgfbsupdatebootstrapper = 1106 +k_emsgfbssetstate = 1107 +k_emsgfbsapplyosupdates = 1108 +k_emsgfbsruncmdscript = 1109 +k_emsgfbsrebootbox = 1110 +k_emsgfbssetbigbrothermode = 1111 +k_emsgfbsminidumpserver = 1112 +k_emsgfbsdeployhotfixpackage = 1114 +k_emsgfbsdeployhotfixresponse = 1115 +k_emsgfbsdownloadhotfix = 1116 +k_emsgfbsdownloadhotfixresponse = 1117 +k_emsgfbsupdatetargetconfigfile = 1118 +k_emsgfbsapplyaccountcred = 1119 +k_emsgfbsapplyaccountcredresponse = 1120 +k_emsgfbssetshellcount = 1121 +k_emsgfbsterminateshell = 1122 +k_emsgfbsquerygmforrequest = 1123 +k_emsgfbsquerygmresponse = 1124 +k_emsgfbsterminatezombies = 1125 +k_emsgfbsinfofrombootstrapper = 1126 +k_emsgfbsrebootboxresponse = 1127 +k_emsgfbsbootstrapperpackagerequest = 1128 +k_emsgfbsbootstrapperpackageresponse = 1129 +k_emsgfbsbootstrappergetpackagechunk = 1130 +k_emsgfbsbootstrappergetpackagechunkresponse = 1131 +k_emsgfbsbootstrapperpackagetransferprogress = 1132 +k_emsgfbsrestartbootstrapper = 1133 +k_emsgfbspausefrozendumps = 1134 +k_emsgbasefilexfer = 1200 +k_emsgfilexferrequest = 1200 +k_emsgfilexferresponse = 1201 +k_emsgfilexferdata = 1202 +k_emsgfilexferend = 1203 +k_emsgfilexferdataack = 1204 +k_emsgbasechannelauth = 1300 +k_emsgchannelauthchallenge = 1300 +k_emsgchannelauthresponse = 1301 +k_emsgchannelauthresult = 1302 +k_emsgchannelencryptrequest = 1303 +k_emsgchannelencryptresponse = 1304 +k_emsgchannelencryptresult = 1305 +k_emsgbasebs = 1400 +k_emsgbspurchasestart = 1401 +k_emsgbspurchaseresponse = 1402 +k_emsgbsauthenticatecctrans = 1403 +k_emsgbsauthenticatecctransresponse = 1404 +k_emsgbssettlecomplete = 1406 +k_emsgbsinitpaypaltxn = 1408 +k_emsgbsinitpaypaltxnresponse = 1409 +k_emsgbsgetpaypaluserinfo = 1410 +k_emsgbsgetpaypaluserinforesponse = 1411 +k_emsgbspaymentinstrban = 1417 +k_emsgbspaymentinstrbanresponse = 1418 +k_emsgbsinitgcbankxfertxn = 1421 +k_emsgbsinitgcbankxfertxnresponse = 1422 +k_emsgbscommitgctxn = 1425 +k_emsgbsquerytransactionstatus = 1426 +k_emsgbsquerytransactionstatusresponse = 1427 +k_emsgbsquerypaymentinstusage = 1431 +k_emsgbsquerypaymentinstresponse = 1432 +k_emsgbsquerytxnextendedinfo = 1433 +k_emsgbsquerytxnextendedinforesponse = 1434 +k_emsgbsupdateconversionrates = 1435 +k_emsgbspurchaserunfraudchecks = 1437 +k_emsgbspurchaserunfraudchecksresponse = 1438 +k_emsgbsquerybankinformation = 1440 +k_emsgbsquerybankinformationresponse = 1441 +k_emsgbsvalidatexsollasignature = 1445 +k_emsgbsvalidatexsollasignatureresponse = 1446 +k_emsgbsqiwiwalletinvoice = 1448 +k_emsgbsqiwiwalletinvoiceresponse = 1449 +k_emsgbsupdateinventoryfrompropack = 1450 +k_emsgbsupdateinventoryfrompropackresponse = 1451 +k_emsgbssendshippingrequest = 1452 +k_emsgbssendshippingrequestresponse = 1453 +k_emsgbsgetpropackorderstatus = 1454 +k_emsgbsgetpropackorderstatusresponse = 1455 +k_emsgbscheckjobrunning = 1456 +k_emsgbscheckjobrunningresponse = 1457 +k_emsgbsresetpackagepurchaseratelimit = 1458 +k_emsgbsresetpackagepurchaseratelimitresponse = 1459 +k_emsgbsupdatepaymentdata = 1460 +k_emsgbsupdatepaymentdataresponse = 1461 +k_emsgbsgetbillingaddress = 1462 +k_emsgbsgetbillingaddressresponse = 1463 +k_emsgbsgetcreditcardinfo = 1464 +k_emsgbsgetcreditcardinforesponse = 1465 +k_emsgbsremoveexpiredpaymentdata = 1468 +k_emsgbsremoveexpiredpaymentdataresponse = 1469 +k_emsgbsconverttocurrentkeys = 1470 +k_emsgbsconverttocurrentkeysresponse = 1471 +k_emsgbsinitpurchase = 1472 +k_emsgbsinitpurchaseresponse = 1473 +k_emsgbscompletepurchase = 1474 +k_emsgbscompletepurchaseresponse = 1475 +k_emsgbsprunecardusagestats = 1476 +k_emsgbsprunecardusagestatsresponse = 1477 +k_emsgbsstorebankinformation = 1478 +k_emsgbsstorebankinformationresponse = 1479 +k_emsgbsverifyposakey = 1480 +k_emsgbsverifyposakeyresponse = 1481 +k_emsgbsreverseredeemposakey = 1482 +k_emsgbsreverseredeemposakeyresponse = 1483 +k_emsgbsqueryfindcreditcard = 1484 +k_emsgbsqueryfindcreditcardresponse = 1485 +k_emsgbsstatusinquiryposakey = 1486 +k_emsgbsstatusinquiryposakeyresponse = 1487 +k_emsgbsboacompraconfirmproductdelivery = 1494 +k_emsgbsboacompraconfirmproductdeliveryresponse = 1495 +k_emsgbsgenerateboacompramd5 = 1496 +k_emsgbsgenerateboacompramd5response = 1497 +k_emsgbscommitwptxn = 1498 +k_emsgbscommitadyentxn = 1499 +k_emsgbaseats = 1500 +k_emsgatsstartstresstest = 1501 +k_emsgatsstopstresstest = 1502 +k_emsgatsrunfailservertest = 1503 +k_emsgatsufsperftesttask = 1504 +k_emsgatsufsperftestresponse = 1505 +k_emsgatscycletcm = 1506 +k_emsgatsinitdrmsstresstest = 1507 +k_emsgatscalltest = 1508 +k_emsgatscalltestreply = 1509 +k_emsgatsstartexternalstress = 1510 +k_emsgatsexternalstressjobstart = 1511 +k_emsgatsexternalstressjobqueued = 1512 +k_emsgatsexternalstressjobrunning = 1513 +k_emsgatsexternalstressjobstopped = 1514 +k_emsgatsexternalstressjobstopall = 1515 +k_emsgatsexternalstressactionresult = 1516 +k_emsgatsstarted = 1517 +k_emsgatscsperftesttask = 1518 +k_emsgatscsperftestresponse = 1519 +k_emsgbasedp = 1600 +k_emsgdpsetpublishingstate = 1601 +k_emsgdpuniqueplayersstat = 1603 +k_emsgdpstreaminguniqueplayersstat = 1604 +k_emsgdpblockingstats = 1607 +k_emsgdpnattraversalstats = 1608 +k_emsgdpcloudstats = 1612 +k_emsgdpgetplayercount = 1615 +k_emsgdpgetplayercountresponse = 1616 +k_emsgdpgameserversplayersstats = 1617 +k_emsgclientdpcheckspecialsurvey = 1620 +k_emsgclientdpcheckspecialsurveyresponse = 1621 +k_emsgclientdpsendspecialsurveyresponse = 1622 +k_emsgclientdpsendspecialsurveyresponsereply = 1623 +k_emsgdpstoresalestatistics = 1624 +k_emsgclientdpupdateappjobreport = 1625 +k_emsgclientdpunsignedinstallscript = 1627 +k_emsgdppartnermicrotxns = 1628 +k_emsgdppartnermicrotxnsresponse = 1629 +k_emsgclientdpcontentstatsreport = 1630 +k_emsgdpvruniqueplayersstat = 1631 +k_emsgbasecm = 1700 +k_emsgcmsetallowstate = 1701 +k_emsgcmspewallowstate = 1702 +k_emsgcmsessionrejected = 1703 +k_emsgcmsetsecrets = 1704 +k_emsgcmgetsecrets = 1705 +k_emsgbasegc = 2200 +k_emsggccmdrevive = 2203 +k_emsggccmddown = 2206 +k_emsggccmddeploy = 2207 +k_emsggccmddeployresponse = 2208 +k_emsggccmdswitch = 2209 +k_emsgamrefreshsessions = 2210 +k_emsggcachievementawarded = 2212 +k_emsggcsystemmessage = 2213 +k_emsggccmdstatus = 2216 +k_emsggcregisterwebinterfaces_deprecated = 2217 +k_emsggcgetaccountdetails_deprecated = 2218 +k_emsggcinterappmessage = 2219 +k_emsggcgetemailtemplate = 2220 +k_emsggcgetemailtemplateresponse = 2221 +k_emsggchrelay = 2222 +k_emsggchrelaytoclient = 2223 +k_emsggchupdatesession = 2224 +k_emsggchrequestupdatesession = 2225 +k_emsggchrequeststatus = 2226 +k_emsggchrequeststatusresponse = 2227 +k_emsggchaccountvacstatuschange = 2228 +k_emsggchspawngc = 2229 +k_emsggchspawngcresponse = 2230 +k_emsggchkillgc = 2231 +k_emsggchkillgcresponse = 2232 +k_emsggchaccounttradebanstatuschange = 2233 +k_emsggchaccountlockstatuschange = 2234 +k_emsggchvacverificationchange = 2235 +k_emsggchaccountphonenumberchange = 2236 +k_emsggchaccounttwofactorchange = 2237 +k_emsggchinviteusertolobby = 2238 +k_emsgbasep2p = 2500 +k_emsgp2pintroducermessage = 2502 +k_emsgbasesm = 2900 +k_emsgsmexpensivereport = 2902 +k_emsgsmhourlyreport = 2903 +k_emsgsmpartitionrenames = 2905 +k_emsgsmmonitorspace = 2906 +k_emsgsmtestnextbuildschemaconversion = 2907 +k_emsgsmtestnextbuildschemaconversionresponse = 2908 +k_emsgbasetest = 3000 +k_emsgfailserver = 3000 +k_emsgjobheartbeattest = 3001 +k_emsgjobheartbeattestresponse = 3002 +k_emsgbaseftsrange = 3100 +k_emsgbaseccsrange = 3150 +k_emsgccsdeleteallcommentsbyauthor = 3161 +k_emsgccsdeleteallcommentsbyauthorresponse = 3162 +k_emsgbaselbsrange = 3200 +k_emsglbssetscore = 3201 +k_emsglbssetscoreresponse = 3202 +k_emsglbsfindorcreatelb = 3203 +k_emsglbsfindorcreatelbresponse = 3204 +k_emsglbsgetlbentries = 3205 +k_emsglbsgetlbentriesresponse = 3206 +k_emsglbsgetlblist = 3207 +k_emsglbsgetlblistresponse = 3208 +k_emsglbssetlbdetails = 3209 +k_emsglbsdeletelb = 3210 +k_emsglbsdeletelbentry = 3211 +k_emsglbsresetlb = 3212 +k_emsglbsresetlbresponse = 3213 +k_emsglbsdeletelbresponse = 3214 +k_emsgbaseogs = 3400 +k_emsgogsbeginsession = 3401 +k_emsgogsbeginsessionresponse = 3402 +k_emsgogsendsession = 3403 +k_emsgogsendsessionresponse = 3404 +k_emsgogswriteappsessionrow = 3406 +k_emsgbasebrp = 3600 +k_emsgbrpposttransactiontax = 3629 +k_emsgbrpposttransactiontaxresponse = 3630 +k_emsgbaseamrange2 = 4000 +k_emsgamcreatechat = 4001 +k_emsgamcreatechatresponse = 4002 +k_emsgamsetprofileurl = 4005 +k_emsgamgetaccountemailaddress = 4006 +k_emsgamgetaccountemailaddressresponse = 4007 +k_emsgamrequestclandata = 4008 +k_emsgamroutetoclients = 4009 +k_emsgamleaveclan = 4010 +k_emsgamclanpermissions = 4011 +k_emsgamclanpermissionsresponse = 4012 +k_emsgamcreateclaneventdummyforratelimiting = 4013 +k_emsgamupdateclaneventdummyforratelimiting = 4015 +k_emsgamsetclanpermissionsettings = 4021 +k_emsgamsetclanpermissionsettingsresponse = 4022 +k_emsgamgetclanpermissionsettings = 4023 +k_emsgamgetclanpermissionsettingsresponse = 4024 +k_emsgampublishchatroominfo = 4025 +k_emsgclientchatroominfo = 4026 +k_emsgamgetclanhistory = 4039 +k_emsgamgetclanhistoryresponse = 4040 +k_emsgamgetclanpermissionbits = 4041 +k_emsgamgetclanpermissionbitsresponse = 4042 +k_emsgamsetclanpermissionbits = 4043 +k_emsgamsetclanpermissionbitsresponse = 4044 +k_emsgamsessioninforequest = 4045 +k_emsgamsessioninforesponse = 4046 +k_emsgamvalidatewgtoken = 4047 +k_emsgamgetclanrank = 4050 +k_emsgamgetclanrankresponse = 4051 +k_emsgamsetclanrank = 4052 +k_emsgamsetclanrankresponse = 4053 +k_emsgamgetclanpotw = 4054 +k_emsgamgetclanpotwresponse = 4055 +k_emsgamsetclanpotw = 4056 +k_emsgamsetclanpotwresponse = 4057 +k_emsgamdumpuser = 4059 +k_emsgamkickuserfromclan = 4060 +k_emsgamaddfoundertoclan = 4061 +k_emsgamvalidatewgtokenresponse = 4062 +k_emsgamsetaccountdetails = 4064 +k_emsgamgetchatbanlist = 4065 +k_emsgamgetchatbanlistresponse = 4066 +k_emsgamunbanfromchat = 4067 +k_emsgamsetclandetails = 4068 +k_emsgamgetaccountlinks = 4069 +k_emsgamgetaccountlinksresponse = 4070 +k_emsgamsetaccountlinks = 4071 +k_emsgamsetaccountlinksresponse = 4072 +k_emsgugsgetusergamestats = 4073 +k_emsgugsgetusergamestatsresponse = 4074 +k_emsgamcheckclanmembership = 4075 +k_emsgamgetclanmembers = 4076 +k_emsgamgetclanmembersresponse = 4077 +k_emsgamnotifychatofclanchange = 4079 +k_emsgamresubmitpurchase = 4080 +k_emsgamaddfriend = 4081 +k_emsgamaddfriendresponse = 4082 +k_emsgamremovefriend = 4083 +k_emsgamdumpclan = 4084 +k_emsgamchangeclanowner = 4085 +k_emsgamcanceleasycollect = 4086 +k_emsgamcanceleasycollectresponse = 4087 +k_emsgamclansincommon = 4090 +k_emsgamclansincommonresponse = 4091 +k_emsgamisvalidaccountid = 4092 +k_emsgamwipefriendslist = 4095 +k_emsgamsetignored = 4096 +k_emsgamclansincommoncountresponse = 4097 +k_emsgamfriendslist = 4098 +k_emsgamfriendslistresponse = 4099 +k_emsgamfriendsincommon = 4100 +k_emsgamfriendsincommonresponse = 4101 +k_emsgamfriendsincommoncountresponse = 4102 +k_emsgamclansincommoncount = 4103 +k_emsgamchallengeverdict = 4104 +k_emsgamchallengenotification = 4105 +k_emsgamfindgsbyip = 4106 +k_emsgamfoundgsbyip = 4107 +k_emsgamgiftrevoked = 4108 +k_emsgamuserclanlist = 4110 +k_emsgamuserclanlistresponse = 4111 +k_emsgamgetaccountdetails2 = 4112 +k_emsgamgetaccountdetailsresponse2 = 4113 +k_emsgamsetcommunityprofilesettings = 4114 +k_emsgamsetcommunityprofilesettingsresponse = 4115 +k_emsgamgetcommunityprivacystate = 4116 +k_emsgamgetcommunityprivacystateresponse = 4117 +k_emsgamcheckclaninviteratelimiting = 4118 +k_emsgugsgetuserachievementstatus = 4119 +k_emsgamgetignored = 4120 +k_emsgamgetignoredresponse = 4121 +k_emsgamsetignoredresponse = 4122 +k_emsgamsetfriendrelationshipnone = 4123 +k_emsgamgetfriendrelationship = 4124 +k_emsgamgetfriendrelationshipresponse = 4125 +k_emsgamservicemodulescache = 4126 +k_emsgamservicemodulescall = 4127 +k_emsgamservicemodulescallresponse = 4128 +k_emsgcommunityaddfriendnews = 4140 +k_emsgamfindclanuser = 4143 +k_emsgamfindclanuserresponse = 4144 +k_emsgambanfromchat = 4145 +k_emsgamgetusernewssubscriptions = 4147 +k_emsgamgetusernewssubscriptionsresponse = 4148 +k_emsgamsetusernewssubscriptions = 4149 +k_emsgamsendqueuedemails = 4152 +k_emsgamsetlicenseflags = 4153 +k_emsgcommunitydeleteusernews = 4155 +k_emsgamallowuserfilesrequest = 4156 +k_emsgamallowuserfilesresponse = 4157 +k_emsgamgetaccountstatus = 4158 +k_emsgamgetaccountstatusresponse = 4159 +k_emsgameditbanreason = 4160 +k_emsgamcheckclanmembershipresponse = 4161 +k_emsgamprobeclanmembershiplist = 4162 +k_emsgamprobeclanmembershiplistresponse = 4163 +k_emsgugsgetuserachievementstatusresponse = 4164 +k_emsgamgetfriendslobbies = 4165 +k_emsgamgetfriendslobbiesresponse = 4166 +k_emsgamgetuserfriendnewsresponse = 4172 +k_emsgcommunitygetuserfriendnews = 4173 +k_emsgamgetuserclansnewsresponse = 4174 +k_emsgamgetuserclansnews = 4175 +k_emsgamgetpreviouscbaccount = 4184 +k_emsgamgetpreviouscbaccountresponse = 4185 +k_emsgamgetuserlicensehistory = 4190 +k_emsgamgetuserlicensehistoryresponse = 4191 +k_emsgamsupportchangepassword = 4194 +k_emsgamsupportchangeemail = 4195 +k_emsgamresetuserverificationgsbyip = 4197 +k_emsgamupdategsplaystats = 4198 +k_emsgamsupportenableordisable = 4199 +k_emsgamgetpurchasestatus = 4206 +k_emsgamsupportisaccountenabled = 4209 +k_emsgamsupportisaccountenabledresponse = 4210 +k_emsgugsgetuserstats = 4211 +k_emsgamsupportkicksession = 4212 +k_emsgamgssearch = 4213 +k_emsgmarketingmessageupdate = 4216 +k_emsgchatserverroutefriendmsg = 4219 +k_emsgamticketauthrequestorresponse = 4220 +k_emsgamverifydepotmanagementrights = 4222 +k_emsgamverifydepotmanagementrightsresponse = 4223 +k_emsgamaddfreelicense = 4224 +k_emsgamvalidateemaillink = 4231 +k_emsgamvalidateemaillinkresponse = 4232 +k_emsgugsstoreuserstats = 4236 +k_emsgamdeletestoredcard = 4241 +k_emsgamrevokelegacygamekeys = 4242 +k_emsgamgetwalletdetails = 4244 +k_emsgamgetwalletdetailsresponse = 4245 +k_emsgamdeletestoredpaymentinfo = 4246 +k_emsgamgetstoredpaymentsummary = 4247 +k_emsgamgetstoredpaymentsummaryresponse = 4248 +k_emsgamgetwalletconversionrate = 4249 +k_emsgamgetwalletconversionrateresponse = 4250 +k_emsgamconvertwallet = 4251 +k_emsgamconvertwalletresponse = 4252 +k_emsgamsetpreapproval = 4255 +k_emsgamsetpreapprovalresponse = 4256 +k_emsgamcreaterefund = 4258 +k_emsgamcreatechargeback = 4260 +k_emsgamcreatedispute = 4262 +k_emsgamcleardispute = 4264 +k_emsgamcreatefinancialadjustment = 4265 +k_emsgamplayernicknamelist = 4266 +k_emsgamplayernicknamelistresponse = 4267 +k_emsgamsetdrmtestconfig = 4268 +k_emsgamgetusercurrentgameinfo = 4269 +k_emsgamgetusercurrentgameinforesponse = 4270 +k_emsgamgetgsplayerlist = 4271 +k_emsgamgetgsplayerlistresponse = 4272 +k_emsgamgetsteamidformicrotxn = 4278 +k_emsgamgetsteamidformicrotxnresponse = 4279 +k_emsgamsetpartnermember = 4280 +k_emsgamremovepublisheruser = 4281 +k_emsgamgetuserlicenselist = 4282 +k_emsgamgetuserlicenselistresponse = 4283 +k_emsgamreloadgamegrouppolicy = 4284 +k_emsgamaddfreelicenseresponse = 4285 +k_emsgamvacstatusupdate = 4286 +k_emsgamgetaccountdetails = 4287 +k_emsgamgetaccountdetailsresponse = 4288 +k_emsgamgetplayerlinkdetails = 4289 +k_emsgamgetplayerlinkdetailsresponse = 4290 +k_emsgamgetaccountflagsforwgspoofing = 4294 +k_emsgamgetaccountflagsforwgspoofingresponse = 4295 +k_emsgamgetclanofficers = 4298 +k_emsgamgetclanofficersresponse = 4299 +k_emsgamnamechange = 4300 +k_emsgamgetnamehistory = 4301 +k_emsgamgetnamehistoryresponse = 4302 +k_emsgamupdateproviderstatus = 4305 +k_emsgamsupportremoveaccountsecurity = 4307 +k_emsgamisaccountincaptchagraceperiod = 4308 +k_emsgamisaccountincaptchagraceperiodresponse = 4309 +k_emsgamaccountps3unlink = 4310 +k_emsgamaccountps3unlinkresponse = 4311 +k_emsgugsstoreuserstatsresponse = 4312 +k_emsgamgetaccountpsninfo = 4313 +k_emsgamgetaccountpsninforesponse = 4314 +k_emsgamauthenticatedplayerlist = 4315 +k_emsgamgetusergifts = 4316 +k_emsgamgetusergiftsresponse = 4317 +k_emsgamtransferlockedgifts = 4320 +k_emsgamtransferlockedgiftsresponse = 4321 +k_emsgamplayerhostedongameserver = 4322 +k_emsgamgetaccountbaninfo = 4323 +k_emsgamgetaccountbaninforesponse = 4324 +k_emsgamrecordbanenforcement = 4325 +k_emsgamrollbackgifttransfer = 4326 +k_emsgamrollbackgifttransferresponse = 4327 +k_emsgamhandlependingtransaction = 4328 +k_emsgamrequestclandetails = 4329 +k_emsgamdeletestoredpaypalagreement = 4330 +k_emsgamgameserverupdate = 4331 +k_emsgamgameserverremove = 4332 +k_emsgamgetpaypalagreements = 4333 +k_emsgamgetpaypalagreementsresponse = 4334 +k_emsgamgameserverplayercompatibilitycheck = 4335 +k_emsgamgameserverplayercompatibilitycheckresponse = 4336 +k_emsgamrenewlicense = 4337 +k_emsgamgetaccountcommunitybaninfo = 4338 +k_emsgamgetaccountcommunitybaninforesponse = 4339 +k_emsgamgameserveraccountchangepassword = 4340 +k_emsgamgameserveraccountdeleteaccount = 4341 +k_emsgamrenewagreement = 4342 +k_emsgamxsollapayment = 4344 +k_emsgamxsollapaymentresponse = 4345 +k_emsgamacctallowedtopurchase = 4346 +k_emsgamacctallowedtopurchaseresponse = 4347 +k_emsgamswapkioskdeposit = 4348 +k_emsgamswapkioskdepositresponse = 4349 +k_emsgamsetusergiftunowned = 4350 +k_emsgamsetusergiftunownedresponse = 4351 +k_emsgamclaimunownedusergift = 4352 +k_emsgamclaimunownedusergiftresponse = 4353 +k_emsgamsetclanname = 4354 +k_emsgamsetclannameresponse = 4355 +k_emsgamgrantcoupon = 4356 +k_emsgamgrantcouponresponse = 4357 +k_emsgamispackagerestrictedinusercountry = 4358 +k_emsgamispackagerestrictedinusercountryresponse = 4359 +k_emsgamhandlependingtransactionresponse = 4360 +k_emsgamgrantguestpasses2 = 4361 +k_emsgamgrantguestpasses2response = 4362 +k_emsgamgetplayerbandetails = 4365 +k_emsgamgetplayerbandetailsresponse = 4366 +k_emsgamfinalizepurchase = 4367 +k_emsgamfinalizepurchaseresponse = 4368 +k_emsgampersonachangeresponse = 4372 +k_emsgamgetclandetailsforforumcreation = 4373 +k_emsgamgetclandetailsforforumcreationresponse = 4374 +k_emsgamgetpendingnotificationcount = 4375 +k_emsgamgetpendingnotificationcountresponse = 4376 +k_emsgampasswordhashupgrade = 4377 +k_emsgamboacomprapayment = 4380 +k_emsgamboacomprapaymentresponse = 4381 +k_emsgamcompleteexternalpurchase = 4383 +k_emsgamcompleteexternalpurchaseresponse = 4384 +k_emsgamresolvenegativewalletcredits = 4385 +k_emsgamresolvenegativewalletcreditsresponse = 4386 +k_emsgamplayergetclanbasicdetails = 4389 +k_emsgamplayergetclanbasicdetailsresponse = 4390 +k_emsgammolpayment = 4391 +k_emsgammolpaymentresponse = 4392 +k_emsggetuseripcountry = 4393 +k_emsggetuseripcountryresponse = 4394 +k_emsgnotificationofsuspiciousactivity = 4395 +k_emsgamdegicapayment = 4396 +k_emsgamdegicapaymentresponse = 4397 +k_emsgameclubpayment = 4398 +k_emsgameclubpaymentresponse = 4399 +k_emsgampaypalpaymentshubpayment = 4400 +k_emsgampaypalpaymentshubpaymentresponse = 4401 +k_emsgamtwofactorrecoverauthenticatorrequest = 4402 +k_emsgamtwofactorrecoverauthenticatorresponse = 4403 +k_emsgamsmart2paypayment = 4404 +k_emsgamsmart2paypaymentresponse = 4405 +k_emsgamvalidatepasswordresetcodeandsendsmsrequest = 4406 +k_emsgamvalidatepasswordresetcodeandsendsmsresponse = 4407 +k_emsgamgetaccountresetdetailsrequest = 4408 +k_emsgamgetaccountresetdetailsresponse = 4409 +k_emsgambitpaypayment = 4410 +k_emsgambitpaypaymentresponse = 4411 +k_emsgamsendaccountinfoupdate = 4412 +k_emsgamsendscheduledgift = 4413 +k_emsgamnodwinpayment = 4414 +k_emsgamnodwinpaymentresponse = 4415 +k_emsgamresolvewalletrevoke = 4416 +k_emsgamresolvewalletreverserevoke = 4417 +k_emsgamfundedpayment = 4418 +k_emsgamfundedpaymentresponse = 4419 +k_emsgamrequestpersonaupdateforchatserver = 4420 +k_emsgamperfectworldpayment = 4421 +k_emsgamperfectworldpaymentresponse = 4422 +k_emsgbasepsrange = 5000 +k_emsgpscreateshoppingcart = 5001 +k_emsgpscreateshoppingcartresponse = 5002 +k_emsgpsisvalidshoppingcart = 5003 +k_emsgpsisvalidshoppingcartresponse = 5004 +k_emsgpsaddpackagetoshoppingcart = 5005 +k_emsgpsaddpackagetoshoppingcartresponse = 5006 +k_emsgpsremovelineitemfromshoppingcart = 5007 +k_emsgpsremovelineitemfromshoppingcartresponse = 5008 +k_emsgpsgetshoppingcartcontents = 5009 +k_emsgpsgetshoppingcartcontentsresponse = 5010 +k_emsgpsaddwalletcredittoshoppingcart = 5011 +k_emsgpsaddwalletcredittoshoppingcartresponse = 5012 +k_emsgbaseufsrange = 5200 +k_emsgclientufsuploadfilerequest = 5202 +k_emsgclientufsuploadfileresponse = 5203 +k_emsgclientufsuploadfilechunk = 5204 +k_emsgclientufsuploadfilefinished = 5205 +k_emsgclientufsgetfilelistforapp = 5206 +k_emsgclientufsgetfilelistforappresponse = 5207 +k_emsgclientufsdownloadrequest = 5210 +k_emsgclientufsdownloadresponse = 5211 +k_emsgclientufsdownloadchunk = 5212 +k_emsgclientufsloginrequest = 5213 +k_emsgclientufsloginresponse = 5214 +k_emsgufsreloadpartitioninfo = 5215 +k_emsgclientufstransferheartbeat = 5216 +k_emsgufssynchronizefile = 5217 +k_emsgufssynchronizefileresponse = 5218 +k_emsgclientufsdeletefilerequest = 5219 +k_emsgclientufsdeletefileresponse = 5220 +k_emsgclientufsgetugcdetails = 5226 +k_emsgclientufsgetugcdetailsresponse = 5227 +k_emsgufsupdatefileflags = 5228 +k_emsgufsupdatefileflagsresponse = 5229 +k_emsgclientufsgetsinglefileinfo = 5230 +k_emsgclientufsgetsinglefileinforesponse = 5231 +k_emsgclientufssharefile = 5232 +k_emsgclientufssharefileresponse = 5233 +k_emsgufsreloadaccount = 5234 +k_emsgufsreloadaccountresponse = 5235 +k_emsgufsupdaterecordbatched = 5236 +k_emsgufsupdaterecordbatchedresponse = 5237 +k_emsgufsmigratefile = 5238 +k_emsgufsmigratefileresponse = 5239 +k_emsgufsgetugcurls = 5240 +k_emsgufsgetugcurlsresponse = 5241 +k_emsgufshttpuploadfilefinishrequest = 5242 +k_emsgufshttpuploadfilefinishresponse = 5243 +k_emsgufsdownloadstartrequest = 5244 +k_emsgufsdownloadstartresponse = 5245 +k_emsgufsdownloadchunkrequest = 5246 +k_emsgufsdownloadchunkresponse = 5247 +k_emsgufsdownloadfinishrequest = 5248 +k_emsgufsdownloadfinishresponse = 5249 +k_emsgufsflushurlcache = 5250 +k_emsgclientufsuploadcommit = 5251 +k_emsgclientufsuploadcommitresponse = 5252 +k_emsgufsmigratefileappid = 5253 +k_emsgufsmigratefileappidresponse = 5254 +k_emsgbaseclient2 = 5400 +k_emsgclientrequestforgottenpasswordemail = 5401 +k_emsgclientrequestforgottenpasswordemailresponse = 5402 +k_emsgclientcreateaccountresponse = 5403 +k_emsgclientresetforgottenpassword = 5404 +k_emsgclientresetforgottenpasswordresponse = 5405 +k_emsgclientinformofresetforgottenpassword = 5407 +k_emsgclientinformofresetforgottenpasswordresponse = 5408 +k_emsgclientanonuserlogon_deprecated = 5409 +k_emsgclientgamesplayedwithdatablob = 5410 +k_emsgclientupdateusergameinfo = 5411 +k_emsgclientfiletodownload = 5412 +k_emsgclientfiletodownloadresponse = 5413 +k_emsgclientlbssetscore = 5414 +k_emsgclientlbssetscoreresponse = 5415 +k_emsgclientlbsfindorcreatelb = 5416 +k_emsgclientlbsfindorcreatelbresponse = 5417 +k_emsgclientlbsgetlbentries = 5418 +k_emsgclientlbsgetlbentriesresponse = 5419 +k_emsgclientchatdeclined = 5426 +k_emsgclientfriendmsgincoming = 5427 +k_emsgclientauthlist_deprecated = 5428 +k_emsgclientticketauthcomplete = 5429 +k_emsgclientislimitedaccount = 5430 +k_emsgclientrequestauthlist = 5431 +k_emsgclientauthlist = 5432 +k_emsgclientstat = 5433 +k_emsgclientp2pconnectioninfo = 5434 +k_emsgclientp2pconnectionfailinfo = 5435 +k_emsgclientgetdepotdecryptionkey = 5438 +k_emsgclientgetdepotdecryptionkeyresponse = 5439 +k_emsggsperformhardwaresurvey = 5440 +k_emsgclientenabletestlicense = 5443 +k_emsgclientenabletestlicenseresponse = 5444 +k_emsgclientdisabletestlicense = 5445 +k_emsgclientdisabletestlicenseresponse = 5446 +k_emsgclientrequestvalidationmail = 5448 +k_emsgclientrequestvalidationmailresponse = 5449 +k_emsgclientcheckappbetapassword = 5450 +k_emsgclientcheckappbetapasswordresponse = 5451 +k_emsgclienttogc = 5452 +k_emsgclientfromgc = 5453 +k_emsgclientrequestchangemail = 5454 +k_emsgclientrequestchangemailresponse = 5455 +k_emsgclientemailaddrinfo = 5456 +k_emsgclientpasswordchange3 = 5457 +k_emsgclientemailchange3 = 5458 +k_emsgclientpersonalqachange3 = 5459 +k_emsgclientresetforgottenpassword3 = 5460 +k_emsgclientrequestforgottenpasswordemail3 = 5461 +k_emsgclientnewloginkey = 5463 +k_emsgclientnewloginkeyaccepted = 5464 +k_emsgclientlogonwithhash_deprecated = 5465 +k_emsgclientstoreuserstats2 = 5466 +k_emsgclientstatsupdated = 5467 +k_emsgclientactivateoemlicense = 5468 +k_emsgclientregisteroemmachine = 5469 +k_emsgclientregisteroemmachineresponse = 5470 +k_emsgclientrequestedclientstats = 5480 +k_emsgclientstat2int32 = 5481 +k_emsgclientstat2 = 5482 +k_emsgclientverifypassword = 5483 +k_emsgclientverifypasswordresponse = 5484 +k_emsgclientdrmdownloadrequest = 5485 +k_emsgclientdrmdownloadresponse = 5486 +k_emsgclientdrmfinalresult = 5487 +k_emsgclientgetfriendswhoplaygame = 5488 +k_emsgclientgetfriendswhoplaygameresponse = 5489 +k_emsgclientogsbeginsession = 5490 +k_emsgclientogsbeginsessionresponse = 5491 +k_emsgclientogsendsession = 5492 +k_emsgclientogsendsessionresponse = 5493 +k_emsgclientogswriterow = 5494 +k_emsgclientdrmtest = 5495 +k_emsgclientdrmtestresult = 5496 +k_emsgclientserverunavailable = 5500 +k_emsgclientserversavailable = 5501 +k_emsgclientregisterauthticketwithcm = 5502 +k_emsgclientgcmsgfailed = 5503 +k_emsgclientmicrotxnauthrequest = 5504 +k_emsgclientmicrotxnauthorize = 5505 +k_emsgclientmicrotxnauthorizeresponse = 5506 +k_emsgclientappminutesplayeddata = 5507 +k_emsgclientgetmicrotxninfo = 5508 +k_emsgclientgetmicrotxninforesponse = 5509 +k_emsgclientmarketingmessageupdate2 = 5510 +k_emsgclientderegisterwithserver = 5511 +k_emsgclientsubscribetopersonafeed = 5512 +k_emsgclientlogon = 5514 +k_emsgclientgetclientdetails = 5515 +k_emsgclientgetclientdetailsresponse = 5516 +k_emsgclientreportoverlaydetourfailure = 5517 +k_emsgclientgetclientapplist = 5518 +k_emsgclientgetclientapplistresponse = 5519 +k_emsgclientinstallclientapp = 5520 +k_emsgclientinstallclientappresponse = 5521 +k_emsgclientuninstallclientapp = 5522 +k_emsgclientuninstallclientappresponse = 5523 +k_emsgclientsetclientappupdatestate = 5524 +k_emsgclientsetclientappupdatestateresponse = 5525 +k_emsgclientrequestencryptedappticket = 5526 +k_emsgclientrequestencryptedappticketresponse = 5527 +k_emsgclientwalletinfoupdate = 5528 +k_emsgclientlbssetugc = 5529 +k_emsgclientlbssetugcresponse = 5530 +k_emsgclientamgetclanofficers = 5531 +k_emsgclientamgetclanofficersresponse = 5532 +k_emsgclientfriendprofileinfo = 5535 +k_emsgclientfriendprofileinforesponse = 5536 +k_emsgclientupdatemachineauth = 5537 +k_emsgclientupdatemachineauthresponse = 5538 +k_emsgclientreadmachineauth = 5539 +k_emsgclientreadmachineauthresponse = 5540 +k_emsgclientrequestmachineauth = 5541 +k_emsgclientrequestmachineauthresponse = 5542 +k_emsgclientscreenshotschanged = 5543 +k_emsgclientgetcdnauthtoken = 5546 +k_emsgclientgetcdnauthtokenresponse = 5547 +k_emsgclientdownloadratestatistics = 5548 +k_emsgclientrequestaccountdata = 5549 +k_emsgclientrequestaccountdataresponse = 5550 +k_emsgclientresetforgottenpassword4 = 5551 +k_emsgclienthidefriend = 5552 +k_emsgclientfriendsgroupslist = 5553 +k_emsgclientgetclanactivitycounts = 5554 +k_emsgclientgetclanactivitycountsresponse = 5555 +k_emsgclientogsreportstring = 5556 +k_emsgclientogsreportbug = 5557 +k_emsgclientsentlogs = 5558 +k_emsgclientlogongameserver = 5559 +k_emsgamclientcreatefriendsgroup = 5560 +k_emsgamclientcreatefriendsgroupresponse = 5561 +k_emsgamclientdeletefriendsgroup = 5562 +k_emsgamclientdeletefriendsgroupresponse = 5563 +k_emsgamclientmanagefriendsgroup = 5564 +k_emsgamclientmanagefriendsgroupresponse = 5565 +k_emsgamclientaddfriendtogroup = 5566 +k_emsgamclientaddfriendtogroupresponse = 5567 +k_emsgamclientremovefriendfromgroup = 5568 +k_emsgamclientremovefriendfromgroupresponse = 5569 +k_emsgclientamgetpersonanamehistory = 5570 +k_emsgclientamgetpersonanamehistoryresponse = 5571 +k_emsgclientrequestfreelicense = 5572 +k_emsgclientrequestfreelicenseresponse = 5573 +k_emsgclientdrmdownloadrequestwithcrashdata = 5574 +k_emsgclientauthlistack = 5575 +k_emsgclientitemannouncements = 5576 +k_emsgclientrequestitemannouncements = 5577 +k_emsgclientfriendmsgechotosender = 5578 +k_emsgclientogsgameserverpingsample = 5581 +k_emsgclientcommentnotifications = 5582 +k_emsgclientrequestcommentnotifications = 5583 +k_emsgclientpersonachangeresponse = 5584 +k_emsgclientrequestwebapiauthenticateusernonce = 5585 +k_emsgclientrequestwebapiauthenticateusernonceresponse = 5586 +k_emsgclientplayernicknamelist = 5587 +k_emsgamclientsetplayernickname = 5588 +k_emsgamclientsetplayernicknameresponse = 5589 +k_emsgclientgetnumberofcurrentplayersdp = 5592 +k_emsgclientgetnumberofcurrentplayersdpresponse = 5593 +k_emsgclientservicemethodlegacy = 5594 +k_emsgclientservicemethodlegacyresponse = 5595 +k_emsgclientfrienduserstatuspublished = 5596 +k_emsgclientcurrentuimode = 5597 +k_emsgclientvanityurlchangednotification = 5598 +k_emsgclientusernotifications = 5599 +k_emsgbasedfs = 5600 +k_emsgdfsgetfile = 5601 +k_emsgdfsinstalllocalfile = 5602 +k_emsgdfsconnection = 5603 +k_emsgdfsconnectionreply = 5604 +k_emsgclientdfsauthenticaterequest = 5605 +k_emsgclientdfsauthenticateresponse = 5606 +k_emsgclientdfsendsession = 5607 +k_emsgdfspurgefile = 5608 +k_emsgdfsroutefile = 5609 +k_emsgdfsgetfilefromserver = 5610 +k_emsgdfsacceptedresponse = 5611 +k_emsgdfsrequestpingback = 5612 +k_emsgdfsrecvtransmitfile = 5613 +k_emsgdfssendtransmitfile = 5614 +k_emsgdfsrequestpingback2 = 5615 +k_emsgdfsresponsepingback2 = 5616 +k_emsgclientdfsdownloadstatus = 5617 +k_emsgdfsstarttransfer = 5618 +k_emsgdfstransfercomplete = 5619 +k_emsgdfsroutefileresponse = 5620 +k_emsgclientnetworkingcertrequest = 5621 +k_emsgclientnetworkingcertrequestresponse = 5622 +k_emsgclientchallengerequest = 5623 +k_emsgclientchallengeresponse = 5624 +k_emsgbadgecraftednotification = 5625 +k_emsgclientnetworkingmobilecertrequest = 5626 +k_emsgclientnetworkingmobilecertrequestresponse = 5627 +k_emsgbasemds = 5800 +k_emsgamtomdsgetdepotdecryptionkey = 5812 +k_emsgmdstoamgetdepotdecryptionkeyresponse = 5813 +k_emsgmdscontentserverconfigrequest = 5827 +k_emsgmdscontentserverconfig = 5828 +k_emsgmdsgetdepotmanifest = 5829 +k_emsgmdsgetdepotmanifestresponse = 5830 +k_emsgmdsgetdepotmanifestchunk = 5831 +k_emsgmdsgetdepotchunk = 5832 +k_emsgmdsgetdepotchunkresponse = 5833 +k_emsgmdsgetdepotchunkchunk = 5834 +k_emsgmdstocsflushchunk = 5844 +k_emsgmdsmigratechunk = 5847 +k_emsgmdsmigratechunkresponse = 5848 +k_emsgmdstocsflushmanifest = 5849 +k_emsgcsbase = 6200 +k_emsgcsping = 6201 +k_emsgcspingresponse = 6202 +k_emsggmsbase = 6400 +k_emsggmsgameserverreplicate = 6401 +k_emsgclientgmsserverquery = 6403 +k_emsggmsclientserverqueryresponse = 6404 +k_emsgamgmsgameserverupdate = 6405 +k_emsgamgmsgameserverremove = 6406 +k_emsggameserveroutofdate = 6407 +k_emsgdeviceauthorizationbase = 6500 +k_emsgclientauthorizelocaldevicerequest = 6501 +k_emsgclientauthorizelocaldeviceresponse = 6502 +k_emsgclientdeauthorizedevicerequest = 6503 +k_emsgclientdeauthorizedevice = 6504 +k_emsgclientuselocaldeviceauthorizations = 6505 +k_emsgclientgetauthorizeddevices = 6506 +k_emsgclientgetauthorizeddevicesresponse = 6507 +k_emsgamnotifysessiondeviceauthorized = 6508 +k_emsgclientauthorizelocaldevicenotification = 6509 +k_emsgmmsbase = 6600 +k_emsgclientmmscreatelobby = 6601 +k_emsgclientmmscreatelobbyresponse = 6602 +k_emsgclientmmsjoinlobby = 6603 +k_emsgclientmmsjoinlobbyresponse = 6604 +k_emsgclientmmsleavelobby = 6605 +k_emsgclientmmsleavelobbyresponse = 6606 +k_emsgclientmmsgetlobbylist = 6607 +k_emsgclientmmsgetlobbylistresponse = 6608 +k_emsgclientmmssetlobbydata = 6609 +k_emsgclientmmssetlobbydataresponse = 6610 +k_emsgclientmmsgetlobbydata = 6611 +k_emsgclientmmslobbydata = 6612 +k_emsgclientmmssendlobbychatmsg = 6613 +k_emsgclientmmslobbychatmsg = 6614 +k_emsgclientmmssetlobbyowner = 6615 +k_emsgclientmmssetlobbyownerresponse = 6616 +k_emsgclientmmssetlobbygameserver = 6617 +k_emsgclientmmslobbygameserverset = 6618 +k_emsgclientmmsuserjoinedlobby = 6619 +k_emsgclientmmsuserleftlobby = 6620 +k_emsgclientmmsinvitetolobby = 6621 +k_emsgclientmmsflushfrenemylistcache = 6622 +k_emsgclientmmsflushfrenemylistcacheresponse = 6623 +k_emsgclientmmssetlobbylinked = 6624 +k_emsgclientmmssetratelimitpolicyonclient = 6625 +k_emsgclientmmsgetlobbystatus = 6626 +k_emsgclientmmsgetlobbystatusresponse = 6627 +k_emsgmmsgetlobbylist = 6628 +k_emsgmmsgetlobbylistresponse = 6629 +k_emsgnonstdmsgbase = 6800 +k_emsgnonstdmsgmemcached = 6801 +k_emsgnonstdmsghttpserver = 6802 +k_emsgnonstdmsghttpclient = 6803 +k_emsgnonstdmsgwgresponse = 6804 +k_emsgnonstdmsgphpsimulator = 6805 +k_emsgnonstdmsgchase = 6806 +k_emsgnonstdmsgdfstransfer = 6807 +k_emsgnonstdmsgtests = 6808 +k_emsgnonstdmsgumqpipeaapl = 6809 +k_emsgnonstdmsgsyslog = 6810 +k_emsgnonstdmsglogsink = 6811 +k_emsgnonstdmsgsteam2emulator = 6812 +k_emsgnonstdmsgrtmpserver = 6813 +k_emsgnonstdmsgwebsocket = 6814 +k_emsgnonstdmsgredis = 6815 +k_emsgudsbase = 7000 +k_emsgclientudsp2psessionstarted = 7001 +k_emsgclientudsp2psessionended = 7002 +k_emsgudsrenderuserauth = 7003 +k_emsgudsrenderuserauthresponse = 7004 +k_emsgclientinvitetogame = 7005 +k_emsgudshassession = 7006 +k_emsgudshassessionresponse = 7007 +k_emsgmpasbase = 7100 +k_emsgmpasvacbanreset = 7101 +k_emsgkgsbase = 7200 +k_emsgucmbase = 7300 +k_emsgclientucmaddscreenshot = 7301 +k_emsgclientucmaddscreenshotresponse = 7302 +k_emsgucmresetcommunitycontent = 7307 +k_emsgucmresetcommunitycontentresponse = 7308 +k_emsgclientucmdeletescreenshot = 7309 +k_emsgclientucmdeletescreenshotresponse = 7310 +k_emsgclientucmpublishfile = 7311 +k_emsgclientucmpublishfileresponse = 7312 +k_emsgclientucmdeletepublishedfile = 7315 +k_emsgclientucmdeletepublishedfileresponse = 7316 +k_emsgclientucmenumerateuserpublishedfiles = 7317 +k_emsgclientucmenumerateuserpublishedfilesresponse = 7318 +k_emsgclientucmenumerateusersubscribedfiles = 7321 +k_emsgclientucmenumerateusersubscribedfilesresponse = 7322 +k_emsgclientucmupdatepublishedfile = 7325 +k_emsgclientucmupdatepublishedfileresponse = 7326 +k_emsgucmupdatepublishedfile = 7327 +k_emsgucmupdatepublishedfileresponse = 7328 +k_emsgucmdeletepublishedfile = 7329 +k_emsgucmdeletepublishedfileresponse = 7330 +k_emsgucmupdatepublishedfilestat = 7331 +k_emsgucmreloadpublishedfile = 7337 +k_emsgucmreloaduserfilelistcaches = 7338 +k_emsgucmpublishedfilereported = 7339 +k_emsgucmpublishedfilepreviewadd = 7341 +k_emsgucmpublishedfilepreviewaddresponse = 7342 +k_emsgucmpublishedfilepreviewremove = 7343 +k_emsgucmpublishedfilepreviewremoveresponse = 7344 +k_emsgucmpublishedfilesubscribed = 7349 +k_emsgucmpublishedfileunsubscribed = 7350 +k_emsgucmpublishfile = 7351 +k_emsgucmpublishfileresponse = 7352 +k_emsgucmpublishedfilechildadd = 7353 +k_emsgucmpublishedfilechildaddresponse = 7354 +k_emsgucmpublishedfilechildremove = 7355 +k_emsgucmpublishedfilechildremoveresponse = 7356 +k_emsgucmpublishedfileparentchanged = 7359 +k_emsgclientucmgetpublishedfilesforuser = 7360 +k_emsgclientucmgetpublishedfilesforuserresponse = 7361 +k_emsgclientucmsetuserpublishedfileaction = 7364 +k_emsgclientucmsetuserpublishedfileactionresponse = 7365 +k_emsgclientucmenumeratepublishedfilesbyuseraction = 7366 +k_emsgclientucmenumeratepublishedfilesbyuseractionresponse = 7367 +k_emsgucmgetusersubscribedfiles = 7369 +k_emsgucmgetusersubscribedfilesresponse = 7370 +k_emsgucmfixstatspublishedfile = 7371 +k_emsgclientucmenumerateusersubscribedfileswithupdates = 7378 +k_emsgclientucmenumerateusersubscribedfileswithupdatesresponse = 7379 +k_emsgucmpublishedfilecontentupdated = 7380 +k_emsgclientucmpublishedfileupdated = 7381 +k_emsgclientworkshopitemchangesrequest = 7382 +k_emsgclientworkshopitemchangesresponse = 7383 +k_emsgclientworkshopiteminforequest = 7384 +k_emsgclientworkshopiteminforesponse = 7385 +k_emsgfsbase = 7500 +k_emsgclientrichpresenceupload = 7501 +k_emsgclientrichpresencerequest = 7502 +k_emsgclientrichpresenceinfo = 7503 +k_emsgfsrichpresencerequest = 7504 +k_emsgfsrichpresenceresponse = 7505 +k_emsgfscomputefrenematrix = 7506 +k_emsgfscomputefrenematrixresponse = 7507 +k_emsgfsplaystatusnotification = 7508 +k_emsgfsaddorremovefollower = 7510 +k_emsgfsaddorremovefollowerresponse = 7511 +k_emsgfsupdatefollowinglist = 7512 +k_emsgfscommentnotification = 7513 +k_emsgfscommentnotificationviewed = 7514 +k_emsgclientfsgetfollowercount = 7515 +k_emsgclientfsgetfollowercountresponse = 7516 +k_emsgclientfsgetisfollowing = 7517 +k_emsgclientfsgetisfollowingresponse = 7518 +k_emsgclientfsenumeratefollowinglist = 7519 +k_emsgclientfsenumeratefollowinglistresponse = 7520 +k_emsgfsgetpendingnotificationcount = 7521 +k_emsgfsgetpendingnotificationcountresponse = 7522 +k_emsgclientchatofflinemessagenotification = 7523 +k_emsgclientchatrequestofflinemessagecount = 7524 +k_emsgclientchatgetfriendmessagehistory = 7525 +k_emsgclientchatgetfriendmessagehistoryresponse = 7526 +k_emsgclientchatgetfriendmessagehistoryforofflinemessages = 7527 +k_emsgclientfsgetfriendssteamlevels = 7528 +k_emsgclientfsgetfriendssteamlevelsresponse = 7529 +k_emsgamrequestfrienddata = 7530 +k_emsgdrmrange2 = 7600 +k_emsgcegversionsetenabledisablerequest = 7600 +k_emsgcegversionsetenabledisableresponse = 7601 +k_emsgcegpropstatusdrmsrequest = 7602 +k_emsgcegpropstatusdrmsresponse = 7603 +k_emsgcegwhackfailurereportrequest = 7604 +k_emsgcegwhackfailurereportresponse = 7605 +k_emsgdrmsfetchversionset = 7606 +k_emsgdrmsfetchversionsetresponse = 7607 +k_emsgeconbase = 7700 +k_emsgecontrading_initiatetraderequest = 7701 +k_emsgecontrading_initiatetradeproposed = 7702 +k_emsgecontrading_initiatetraderesponse = 7703 +k_emsgecontrading_initiatetraderesult = 7704 +k_emsgecontrading_startsession = 7705 +k_emsgecontrading_canceltraderequest = 7706 +k_emsgeconflushinventorycache = 7707 +k_emsgeconflushinventorycacheresponse = 7708 +k_emsgeconcdkeyprocesstransaction = 7711 +k_emsgeconcdkeyprocesstransactionresponse = 7712 +k_emsgecongeterrorlogs = 7713 +k_emsgecongeterrorlogsresponse = 7714 +k_emsgrmrange = 7800 +k_emsgrmtestverisignotp = 7800 +k_emsgrmtestverisignotpresponse = 7801 +k_emsgrmdeletememcachedkeys = 7803 +k_emsgrmremoteinvoke = 7804 +k_emsgbadloginiplist = 7805 +k_emsgrmmsgtraceaddtrigger = 7806 +k_emsgrmmsgtraceremovetrigger = 7807 +k_emsgrmmsgtraceevent = 7808 +k_emsgugsbase = 7900 +k_emsgugsupdateglobalstats = 7900 +k_emsgclientugsgetglobalstats = 7901 +k_emsgclientugsgetglobalstatsresponse = 7902 +k_emsgstorebase = 8000 +k_emsgumqbase = 8100 +k_emsgumqlogonrequest = 8100 +k_emsgumqlogonresponse = 8101 +k_emsgumqlogoffrequest = 8102 +k_emsgumqlogoffresponse = 8103 +k_emsgumqsendchatmessage = 8104 +k_emsgumqincomingchatmessage = 8105 +k_emsgumqpoll = 8106 +k_emsgumqpollresults = 8107 +k_emsgumq2am_clientmsgbatch = 8108 +k_emsgworkshopbase = 8200 +k_emsgwebapibase = 8300 +k_emsgwebapivalidateoauth2token = 8300 +k_emsgwebapivalidateoauth2tokenresponse = 8301 +k_emsgwebapiregistergcinterfaces = 8303 +k_emsgwebapiinvalidateoauthclientcache = 8304 +k_emsgwebapiinvalidateoauthtokencache = 8305 +k_emsgwebapisetsecrets = 8306 +k_emsgbackpackbase = 8400 +k_emsgbackpackaddtocurrency = 8401 +k_emsgbackpackaddtocurrencyresponse = 8402 +k_emsgcrebase = 8500 +k_emsgcreitemvotesummary = 8503 +k_emsgcreitemvotesummaryresponse = 8504 +k_emsgcreupdateuserpublisheditemvote = 8507 +k_emsgcreupdateuserpublisheditemvoteresponse = 8508 +k_emsgcregetuserpublisheditemvotedetails = 8509 +k_emsgcregetuserpublisheditemvotedetailsresponse = 8510 +k_emsgcrepublishedfilevoteadded = 8513 +k_emsgsecretsbase = 8600 +k_emsgsecretsrequestcredentialpair = 8600 +k_emsgsecretscredentialpairresponse = 8601 +k_emsgboxmonitorbase = 8700 +k_emsgboxmonitorreportrequest = 8700 +k_emsgboxmonitorreportresponse = 8701 +k_emsglogsinkbase = 8800 +k_emsglogsinkwritereport = 8800 +k_emsgpicsbase = 8900 +k_emsgclientpicschangessincerequest = 8901 +k_emsgclientpicschangessinceresponse = 8902 +k_emsgclientpicsproductinforequest = 8903 +k_emsgclientpicsproductinforesponse = 8904 +k_emsgclientpicsaccesstokenrequest = 8905 +k_emsgclientpicsaccesstokenresponse = 8906 +k_emsgworkerprocess = 9000 +k_emsgworkerprocesspingrequest = 9000 +k_emsgworkerprocesspingresponse = 9001 +k_emsgworkerprocessshutdown = 9002 +k_emsgdrmworkerprocess = 9100 +k_emsgdrmworkerprocessdrmandsign = 9100 +k_emsgdrmworkerprocessdrmandsignresponse = 9101 +k_emsgdrmworkerprocesssteamworksinforequest = 9102 +k_emsgdrmworkerprocesssteamworksinforesponse = 9103 +k_emsgdrmworkerprocessinstalldrmdllrequest = 9104 +k_emsgdrmworkerprocessinstalldrmdllresponse = 9105 +k_emsgdrmworkerprocesssecretidstringrequest = 9106 +k_emsgdrmworkerprocesssecretidstringresponse = 9107 +k_emsgdrmworkerprocessinstallprocessedfilesrequest = 9110 +k_emsgdrmworkerprocessinstallprocessedfilesresponse = 9111 +k_emsgdrmworkerprocessexamineblobrequest = 9112 +k_emsgdrmworkerprocessexamineblobresponse = 9113 +k_emsgdrmworkerprocessdescribesecretrequest = 9114 +k_emsgdrmworkerprocessdescribesecretresponse = 9115 +k_emsgdrmworkerprocessbackfilloriginalrequest = 9116 +k_emsgdrmworkerprocessbackfilloriginalresponse = 9117 +k_emsgdrmworkerprocessvalidatedrmdllrequest = 9118 +k_emsgdrmworkerprocessvalidatedrmdllresponse = 9119 +k_emsgdrmworkerprocessvalidatefilerequest = 9120 +k_emsgdrmworkerprocessvalidatefileresponse = 9121 +k_emsgdrmworkerprocesssplitandinstallrequest = 9122 +k_emsgdrmworkerprocesssplitandinstallresponse = 9123 +k_emsgdrmworkerprocessgetblobrequest = 9124 +k_emsgdrmworkerprocessgetblobresponse = 9125 +k_emsgdrmworkerprocessevaluatecrashrequest = 9126 +k_emsgdrmworkerprocessevaluatecrashresponse = 9127 +k_emsgdrmworkerprocessanalyzefilerequest = 9128 +k_emsgdrmworkerprocessanalyzefileresponse = 9129 +k_emsgdrmworkerprocessunpackblobrequest = 9130 +k_emsgdrmworkerprocessunpackblobresponse = 9131 +k_emsgdrmworkerprocessinstallallrequest = 9132 +k_emsgdrmworkerprocessinstallallresponse = 9133 +k_emsgtestworkerprocess = 9200 +k_emsgtestworkerprocessloadunloadmodulerequest = 9200 +k_emsgtestworkerprocessloadunloadmoduleresponse = 9201 +k_emsgtestworkerprocessservicemodulecallrequest = 9202 +k_emsgtestworkerprocessservicemodulecallresponse = 9203 +k_emsgquestserverbase = 9300 +k_emsgclientgetemoticonlist = 9330 +k_emsgclientemoticonlist = 9331 +k_emsgslcbase = 9400 +k_emsgslcusersessionstatus = 9400 +k_emsgslcrequestusersessionstatus = 9401 +k_emsgslcsharedlicenseslockstatus = 9402 +k_emsgclientsharedlibrarylockstatus = 9405 +k_emsgclientsharedlibrarystopplaying = 9406 +k_emsgslcownerlibrarychanged = 9407 +k_emsgslcsharedlibrarychanged = 9408 +k_emsgremoteclientbase = 9500 +k_emsgremoteclientauth_obsolete = 9500 +k_emsgremoteclientauthresponse_obsolete = 9501 +k_emsgremoteclientappstatus = 9502 +k_emsgremoteclientstartstream = 9503 +k_emsgremoteclientstartstreamresponse = 9504 +k_emsgremoteclientping = 9505 +k_emsgremoteclientpingresponse = 9506 +k_emsgclientunlockstreaming = 9507 +k_emsgclientunlockstreamingresponse = 9508 +k_emsgremoteclientaccepteula = 9509 +k_emsgremoteclientgetcontrollerconfig = 9510 +k_emsgremoteclientgetcontrollerconfigresponse = 9511 +k_emsgremoteclientstreamingenabled = 9512 +k_emsgclientunlockhevc = 9513 +k_emsgclientunlockhevcresponse = 9514 +k_emsgremoteclientstatusrequest = 9515 +k_emsgremoteclientstatusresponse = 9516 +k_emsgclientconcurrentsessionsbase = 9600 +k_emsgclientplayingsessionstate = 9600 +k_emsgclientkickplayingsession = 9601 +k_emsgclientbroadcastbase = 9700 +k_emsgclientbroadcastinit = 9700 +k_emsgclientbroadcastframes = 9701 +k_emsgclientbroadcastdisconnect = 9702 +k_emsgclientbroadcastscreenshot = 9703 +k_emsgclientbroadcastuploadconfig = 9704 +k_emsgbaseclient3 = 9800 +k_emsgclientvoicecallpreauthorize = 9800 +k_emsgclientvoicecallpreauthorizeresponse = 9801 +k_emsgclientservertimestamprequest = 9802 +k_emsgclientservertimestampresponse = 9803 +k_emsgclientlanp2pbase = 9900 +k_emsgclientlanp2prequestchunk = 9900 +k_emsgclientlanp2prequestchunkresponse = 9901 +k_emsgclientlanp2pmax = 9999 +k_emsgbasewatchdogserver = 10000 +k_emsgnotifywatchdog = 10000 +k_emsgclientsitelicensebase = 10100 +k_emsgclientsitelicensesiteinfonotification = 10100 +k_emsgclientsitelicensecheckout = 10101 +k_emsgclientsitelicensecheckoutresponse = 10102 +k_emsgclientsitelicensegetavailableseats = 10103 +k_emsgclientsitelicensegetavailableseatsresponse = 10104 +k_emsgclientsitelicensegetcontentcacheinfo = 10105 +k_emsgclientsitelicensegetcontentcacheinforesponse = 10106 +k_emsgbasechatserver = 12000 +k_emsgchatservergetpendingnotificationcount = 12000 +k_emsgchatservergetpendingnotificationcountresponse = 12001 +k_emsgbasesecretserver = 12100 +k_emsgserversecretchanged = 12100 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_emsg(e EMsg, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_emsg(buf []byte, tag_wiretype vproto.WireType) ?(int, EMsg) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EMsg(v) +} +[_allow_multiple_values] +enum EClientPersonaStateFlag { +k_eclientpersonastateflagstatus = 1 +k_eclientpersonastateflagplayername = 2 +k_eclientpersonastateflagqueryport = 4 +k_eclientpersonastateflagsourceid = 8 +k_eclientpersonastateflagpresence = 16 +k_eclientpersonastateflaglastseen = 64 +k_eclientpersonastateflaguserclanrank = 128 +k_eclientpersonastategameextrainfo = 256 +k_eclientpersonastategamedatablob = 512 +k_eclientpersonastateflagclandata = 1024 +k_eclientpersonastateflagfacebook = 2048 +k_eclientpersonastateflagrichpresence = 4096 +k_eclientpersonastateflagbroadcast = 8192 +k_eclientpersonastateflagwatching = 16384 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_eclientpersonastateflag(e EClientPersonaStateFlag, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_eclientpersonastateflag(buf []byte, tag_wiretype vproto.WireType) ?(int, EClientPersonaStateFlag) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EClientPersonaStateFlag(v) +} +[_allow_multiple_values] +enum EMsgClanAccountFlags { +k_emsgclanaccountflagpublic = 1 +k_emsgclanaccountflaglarge = 2 +k_emsgclanaccountflaglocked = 4 +k_emsgclanaccountflagdisabled = 8 +k_emsgclanaccountflagogg = 16 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_emsgclanaccountflags(e EMsgClanAccountFlags, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_emsgclanaccountflags(buf []byte, tag_wiretype vproto.WireType) ?(int, EMsgClanAccountFlags) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EMsgClanAccountFlags(v) +} +[_allow_multiple_values] +enum ESteamReviewScore { +k_esteamreviewscore_overwhelminglypositive = 9 +k_esteamreviewscore_verypositive = 8 +k_esteamreviewscore_positive = 7 +k_esteamreviewscore_mostlypositive = 6 +k_esteamreviewscore_mixed = 5 +k_esteamreviewscore_mostlynegative = 4 +k_esteamreviewscore_negative = 3 +k_esteamreviewscore_verynegative = 2 +k_esteamreviewscore_overwhelminglynegative = 1 +k_esteamreviewscore_none = 0 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_esteamreviewscore(e ESteamReviewScore, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_esteamreviewscore(buf []byte, tag_wiretype vproto.WireType) ?(int, ESteamReviewScore) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, ESteamReviewScore(v) +} diff --git a/proto/google/protobuf/descriptor_pb.v b/proto/google/protobuf/descriptor_pb.v new file mode 100644 index 0000000..80d1ff4 --- /dev/null +++ b/proto/google/protobuf/descriptor_pb.v @@ -0,0 +1,2198 @@ + +// Generated by vproto - Do not modify +module protobuf + +import emily33901.vproto + + +pub struct FileDescriptorSet { +mut: +unknown_fields []vproto.UnknownField +pub mut: +file []FileDescriptorProto +} +pub fn (o &FileDescriptorSet) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.file { +res << zzz_vproto_internal_pack_filedescriptorproto(x, 1) +} + +return res +} + +pub fn filedescriptorset_unpack(buf []byte) ?FileDescriptorSet { +mut res := FileDescriptorSet{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_filedescriptorproto(cur_buf, tag_wiretype.wire_type)? +res.file << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_filedescriptorset() FileDescriptorSet { +return FileDescriptorSet{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_filedescriptorset(o FileDescriptorSet, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_filedescriptorset(buf []byte, tag_wiretype vproto.WireType) ?(int, FileDescriptorSet) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := filedescriptorset_unpack(v)? +return i, unpacked +} +pub struct FileDescriptorProto { +mut: +unknown_fields []vproto.UnknownField +pub mut: +name string +has_name bool +package string +has_package bool +dependency []string +public_dependency []int +weak_dependency []int +message_type []DescriptorProto +enum_type []EnumDescriptorProto +service []ServiceDescriptorProto +extension []FieldDescriptorProto +options FileOptions +has_options bool +source_code_info SourceCodeInfo +has_source_code_info bool +} +pub fn (o &FileDescriptorProto) pack() []byte { +mut res := []byte{} +if o.has_name { +res << vproto.pack_string_field(o.name, 1) +} + +if o.has_package { +res << vproto.pack_string_field(o.package, 2) +} + +// [packed=false] +for _, x in o.dependency { +res << vproto.pack_string_field(x, 3) +} + +// [packed=false] +for _, x in o.public_dependency { +res << vproto.pack_int32_field(x, 10) +} + +// [packed=false] +for _, x in o.weak_dependency { +res << vproto.pack_int32_field(x, 11) +} + +// [packed=false] +for _, x in o.message_type { +res << zzz_vproto_internal_pack_descriptorproto(x, 4) +} + +// [packed=false] +for _, x in o.enum_type { +res << zzz_vproto_internal_pack_enumdescriptorproto(x, 5) +} + +// [packed=false] +for _, x in o.service { +res << zzz_vproto_internal_pack_servicedescriptorproto(x, 6) +} + +// [packed=false] +for _, x in o.extension { +res << zzz_vproto_internal_pack_fielddescriptorproto(x, 7) +} + +if o.has_options { +res << zzz_vproto_internal_pack_fileoptions(o.options, 8) +} + +if o.has_source_code_info { +res << zzz_vproto_internal_pack_sourcecodeinfo(o.source_code_info, 9) +} + +return res +} + +pub fn filedescriptorproto_unpack(buf []byte) ?FileDescriptorProto { +mut res := FileDescriptorProto{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +2 { +res.has_package = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.package = v +i = ii +} + +3 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.dependency << v +i = ii +} + +10 { +// [packed=false] +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.public_dependency << v +i = ii +} + +11 { +// [packed=false] +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.weak_dependency << v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_descriptorproto(cur_buf, tag_wiretype.wire_type)? +res.message_type << v +i = ii +} + +5 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_enumdescriptorproto(cur_buf, tag_wiretype.wire_type)? +res.enum_type << v +i = ii +} + +6 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_servicedescriptorproto(cur_buf, tag_wiretype.wire_type)? +res.service << v +i = ii +} + +7 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_fielddescriptorproto(cur_buf, tag_wiretype.wire_type)? +res.extension << v +i = ii +} + +8 { +res.has_options = true +ii, v := zzz_vproto_internal_unpack_fileoptions(cur_buf, tag_wiretype.wire_type)? +res.options = v +i = ii +} + +9 { +res.has_source_code_info = true +ii, v := zzz_vproto_internal_unpack_sourcecodeinfo(cur_buf, tag_wiretype.wire_type)? +res.source_code_info = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_filedescriptorproto() FileDescriptorProto { +return FileDescriptorProto{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_filedescriptorproto(o FileDescriptorProto, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_filedescriptorproto(buf []byte, tag_wiretype vproto.WireType) ?(int, FileDescriptorProto) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := filedescriptorproto_unpack(v)? +return i, unpacked +} +pub struct DescriptorProtoExtensionRange { +mut: +unknown_fields []vproto.UnknownField +pub mut: +start int +has_start bool +end int +has_end bool +} +pub fn (o &DescriptorProtoExtensionRange) pack() []byte { +mut res := []byte{} +if o.has_start { +res << vproto.pack_int32_field(o.start, 1) +} + +if o.has_end { +res << vproto.pack_int32_field(o.end, 2) +} + +return res +} + +pub fn descriptorprotoextensionrange_unpack(buf []byte) ?DescriptorProtoExtensionRange { +mut res := DescriptorProtoExtensionRange{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_start = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.start = v +i = ii +} + +2 { +res.has_end = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.end = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_descriptorprotoextensionrange() DescriptorProtoExtensionRange { +return DescriptorProtoExtensionRange{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_descriptorprotoextensionrange(o DescriptorProtoExtensionRange, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_descriptorprotoextensionrange(buf []byte, tag_wiretype vproto.WireType) ?(int, DescriptorProtoExtensionRange) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := descriptorprotoextensionrange_unpack(v)? +return i, unpacked +} +pub struct DescriptorProto { +mut: +unknown_fields []vproto.UnknownField +pub mut: +name string +has_name bool +field []FieldDescriptorProto +extension []FieldDescriptorProto +nested_type []DescriptorProto +enum_type []EnumDescriptorProto +extension_range []DescriptorProtoExtensionRange +oneof_decl []OneofDescriptorProto +options MessageOptions +has_options bool +} +pub fn (o &DescriptorProto) pack() []byte { +mut res := []byte{} +if o.has_name { +res << vproto.pack_string_field(o.name, 1) +} + +// [packed=false] +for _, x in o.field { +res << zzz_vproto_internal_pack_fielddescriptorproto(x, 2) +} + +// [packed=false] +for _, x in o.extension { +res << zzz_vproto_internal_pack_fielddescriptorproto(x, 6) +} + +// [packed=false] +for _, x in o.nested_type { +res << zzz_vproto_internal_pack_descriptorproto(x, 3) +} + +// [packed=false] +for _, x in o.enum_type { +res << zzz_vproto_internal_pack_enumdescriptorproto(x, 4) +} + +// [packed=false] +for _, x in o.extension_range { +res << zzz_vproto_internal_pack_descriptorprotoextensionrange(x, 5) +} + +// [packed=false] +for _, x in o.oneof_decl { +res << zzz_vproto_internal_pack_oneofdescriptorproto(x, 8) +} + +if o.has_options { +res << zzz_vproto_internal_pack_messageoptions(o.options, 7) +} + +return res +} + +pub fn descriptorproto_unpack(buf []byte) ?DescriptorProto { +mut res := DescriptorProto{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_fielddescriptorproto(cur_buf, tag_wiretype.wire_type)? +res.field << v +i = ii +} + +6 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_fielddescriptorproto(cur_buf, tag_wiretype.wire_type)? +res.extension << v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_descriptorproto(cur_buf, tag_wiretype.wire_type)? +res.nested_type << v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_enumdescriptorproto(cur_buf, tag_wiretype.wire_type)? +res.enum_type << v +i = ii +} + +5 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_descriptorprotoextensionrange(cur_buf, tag_wiretype.wire_type)? +res.extension_range << v +i = ii +} + +8 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_oneofdescriptorproto(cur_buf, tag_wiretype.wire_type)? +res.oneof_decl << v +i = ii +} + +7 { +res.has_options = true +ii, v := zzz_vproto_internal_unpack_messageoptions(cur_buf, tag_wiretype.wire_type)? +res.options = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_descriptorproto() DescriptorProto { +return DescriptorProto{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_descriptorproto(o DescriptorProto, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_descriptorproto(buf []byte, tag_wiretype vproto.WireType) ?(int, DescriptorProto) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := descriptorproto_unpack(v)? +return i, unpacked +} +[_allow_multiple_values] +enum FieldDescriptorProtoType { +type_double = 1 +type_float = 2 +type_int64 = 3 +type_uint64 = 4 +type_int32 = 5 +type_fixed64 = 6 +type_fixed32 = 7 +type_bool = 8 +type_string = 9 +type_group = 10 +type_message = 11 +type_bytes = 12 +type_uint32 = 13 +type_enum = 14 +type_sfixed32 = 15 +type_sfixed64 = 16 +type_sint32 = 17 +type_sint64 = 18 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_fielddescriptorprototype(e FieldDescriptorProtoType, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_fielddescriptorprototype(buf []byte, tag_wiretype vproto.WireType) ?(int, FieldDescriptorProtoType) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, FieldDescriptorProtoType(v) +} +[_allow_multiple_values] +enum FieldDescriptorProtoLabel { +label_optional = 1 +label_required = 2 +label_repeated = 3 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_fielddescriptorprotolabel(e FieldDescriptorProtoLabel, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_fielddescriptorprotolabel(buf []byte, tag_wiretype vproto.WireType) ?(int, FieldDescriptorProtoLabel) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, FieldDescriptorProtoLabel(v) +} +pub struct FieldDescriptorProto { +mut: +unknown_fields []vproto.UnknownField +pub mut: +name string +has_name bool +number int +has_number bool +label FieldDescriptorProtoLabel +has_label bool +@type FieldDescriptorProtoType +has_type bool +type_name string +has_type_name bool +extendee string +has_extendee bool +default_value string +has_default_value bool +oneof_index int +has_oneof_index bool +options FieldOptions +has_options bool +} +pub fn (o &FieldDescriptorProto) pack() []byte { +mut res := []byte{} +if o.has_name { +res << vproto.pack_string_field(o.name, 1) +} + +if o.has_number { +res << vproto.pack_int32_field(o.number, 3) +} + +if o.has_label { +res << zzz_vproto_internal_pack_fielddescriptorprotolabel(o.label, 4) +} + +if o.has_type { +res << zzz_vproto_internal_pack_fielddescriptorprototype(o.@type, 5) +} + +if o.has_type_name { +res << vproto.pack_string_field(o.type_name, 6) +} + +if o.has_extendee { +res << vproto.pack_string_field(o.extendee, 2) +} + +if o.has_default_value { +res << vproto.pack_string_field(o.default_value, 7) +} + +if o.has_oneof_index { +res << vproto.pack_int32_field(o.oneof_index, 9) +} + +if o.has_options { +res << zzz_vproto_internal_pack_fieldoptions(o.options, 8) +} + +return res +} + +pub fn fielddescriptorproto_unpack(buf []byte) ?FieldDescriptorProto { +mut res := FieldDescriptorProto{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +3 { +res.has_number = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.number = v +i = ii +} + +4 { +res.has_label = true +ii, v := zzz_vproto_internal_unpack_fielddescriptorprotolabel(cur_buf, tag_wiretype.wire_type)? +res.label = v +i = ii +} + +5 { +res.has_type = true +ii, v := zzz_vproto_internal_unpack_fielddescriptorprototype(cur_buf, tag_wiretype.wire_type)? +res.@type = v +i = ii +} + +6 { +res.has_type_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.type_name = v +i = ii +} + +2 { +res.has_extendee = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.extendee = v +i = ii +} + +7 { +res.has_default_value = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.default_value = v +i = ii +} + +9 { +res.has_oneof_index = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.oneof_index = v +i = ii +} + +8 { +res.has_options = true +ii, v := zzz_vproto_internal_unpack_fieldoptions(cur_buf, tag_wiretype.wire_type)? +res.options = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_fielddescriptorproto() FieldDescriptorProto { +return FieldDescriptorProto{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_fielddescriptorproto(o FieldDescriptorProto, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_fielddescriptorproto(buf []byte, tag_wiretype vproto.WireType) ?(int, FieldDescriptorProto) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := fielddescriptorproto_unpack(v)? +return i, unpacked +} +pub struct OneofDescriptorProto { +mut: +unknown_fields []vproto.UnknownField +pub mut: +name string +has_name bool +} +pub fn (o &OneofDescriptorProto) pack() []byte { +mut res := []byte{} +if o.has_name { +res << vproto.pack_string_field(o.name, 1) +} + +return res +} + +pub fn oneofdescriptorproto_unpack(buf []byte) ?OneofDescriptorProto { +mut res := OneofDescriptorProto{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_oneofdescriptorproto() OneofDescriptorProto { +return OneofDescriptorProto{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_oneofdescriptorproto(o OneofDescriptorProto, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_oneofdescriptorproto(buf []byte, tag_wiretype vproto.WireType) ?(int, OneofDescriptorProto) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := oneofdescriptorproto_unpack(v)? +return i, unpacked +} +pub struct EnumDescriptorProto { +mut: +unknown_fields []vproto.UnknownField +pub mut: +name string +has_name bool +value []EnumValueDescriptorProto +options EnumOptions +has_options bool +} +pub fn (o &EnumDescriptorProto) pack() []byte { +mut res := []byte{} +if o.has_name { +res << vproto.pack_string_field(o.name, 1) +} + +// [packed=false] +for _, x in o.value { +res << zzz_vproto_internal_pack_enumvaluedescriptorproto(x, 2) +} + +if o.has_options { +res << zzz_vproto_internal_pack_enumoptions(o.options, 3) +} + +return res +} + +pub fn enumdescriptorproto_unpack(buf []byte) ?EnumDescriptorProto { +mut res := EnumDescriptorProto{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_enumvaluedescriptorproto(cur_buf, tag_wiretype.wire_type)? +res.value << v +i = ii +} + +3 { +res.has_options = true +ii, v := zzz_vproto_internal_unpack_enumoptions(cur_buf, tag_wiretype.wire_type)? +res.options = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_enumdescriptorproto() EnumDescriptorProto { +return EnumDescriptorProto{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_enumdescriptorproto(o EnumDescriptorProto, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_enumdescriptorproto(buf []byte, tag_wiretype vproto.WireType) ?(int, EnumDescriptorProto) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := enumdescriptorproto_unpack(v)? +return i, unpacked +} +pub struct EnumValueDescriptorProto { +mut: +unknown_fields []vproto.UnknownField +pub mut: +name string +has_name bool +number int +has_number bool +options EnumValueOptions +has_options bool +} +pub fn (o &EnumValueDescriptorProto) pack() []byte { +mut res := []byte{} +if o.has_name { +res << vproto.pack_string_field(o.name, 1) +} + +if o.has_number { +res << vproto.pack_int32_field(o.number, 2) +} + +if o.has_options { +res << zzz_vproto_internal_pack_enumvalueoptions(o.options, 3) +} + +return res +} + +pub fn enumvaluedescriptorproto_unpack(buf []byte) ?EnumValueDescriptorProto { +mut res := EnumValueDescriptorProto{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +2 { +res.has_number = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.number = v +i = ii +} + +3 { +res.has_options = true +ii, v := zzz_vproto_internal_unpack_enumvalueoptions(cur_buf, tag_wiretype.wire_type)? +res.options = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_enumvaluedescriptorproto() EnumValueDescriptorProto { +return EnumValueDescriptorProto{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_enumvaluedescriptorproto(o EnumValueDescriptorProto, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_enumvaluedescriptorproto(buf []byte, tag_wiretype vproto.WireType) ?(int, EnumValueDescriptorProto) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := enumvaluedescriptorproto_unpack(v)? +return i, unpacked +} +pub struct ServiceDescriptorProto { +mut: +unknown_fields []vproto.UnknownField +pub mut: +name string +has_name bool +method []MethodDescriptorProto +options ServiceOptions +has_options bool +} +pub fn (o &ServiceDescriptorProto) pack() []byte { +mut res := []byte{} +if o.has_name { +res << vproto.pack_string_field(o.name, 1) +} + +// [packed=false] +for _, x in o.method { +res << zzz_vproto_internal_pack_methoddescriptorproto(x, 2) +} + +if o.has_options { +res << zzz_vproto_internal_pack_serviceoptions(o.options, 3) +} + +return res +} + +pub fn servicedescriptorproto_unpack(buf []byte) ?ServiceDescriptorProto { +mut res := ServiceDescriptorProto{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_methoddescriptorproto(cur_buf, tag_wiretype.wire_type)? +res.method << v +i = ii +} + +3 { +res.has_options = true +ii, v := zzz_vproto_internal_unpack_serviceoptions(cur_buf, tag_wiretype.wire_type)? +res.options = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_servicedescriptorproto() ServiceDescriptorProto { +return ServiceDescriptorProto{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_servicedescriptorproto(o ServiceDescriptorProto, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_servicedescriptorproto(buf []byte, tag_wiretype vproto.WireType) ?(int, ServiceDescriptorProto) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := servicedescriptorproto_unpack(v)? +return i, unpacked +} +pub struct MethodDescriptorProto { +mut: +unknown_fields []vproto.UnknownField +pub mut: +name string +has_name bool +input_type string +has_input_type bool +output_type string +has_output_type bool +options MethodOptions +has_options bool +} +pub fn (o &MethodDescriptorProto) pack() []byte { +mut res := []byte{} +if o.has_name { +res << vproto.pack_string_field(o.name, 1) +} + +if o.has_input_type { +res << vproto.pack_string_field(o.input_type, 2) +} + +if o.has_output_type { +res << vproto.pack_string_field(o.output_type, 3) +} + +if o.has_options { +res << zzz_vproto_internal_pack_methodoptions(o.options, 4) +} + +return res +} + +pub fn methoddescriptorproto_unpack(buf []byte) ?MethodDescriptorProto { +mut res := MethodDescriptorProto{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +2 { +res.has_input_type = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.input_type = v +i = ii +} + +3 { +res.has_output_type = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.output_type = v +i = ii +} + +4 { +res.has_options = true +ii, v := zzz_vproto_internal_unpack_methodoptions(cur_buf, tag_wiretype.wire_type)? +res.options = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_methoddescriptorproto() MethodDescriptorProto { +return MethodDescriptorProto{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_methoddescriptorproto(o MethodDescriptorProto, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_methoddescriptorproto(buf []byte, tag_wiretype vproto.WireType) ?(int, MethodDescriptorProto) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := methoddescriptorproto_unpack(v)? +return i, unpacked +} +[_allow_multiple_values] +enum FileOptionsOptimizeMode { +speed = 1 +code_size = 2 +lite_runtime = 3 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_fileoptionsoptimizemode(e FileOptionsOptimizeMode, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_fileoptionsoptimizemode(buf []byte, tag_wiretype vproto.WireType) ?(int, FileOptionsOptimizeMode) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, FileOptionsOptimizeMode(v) +} +pub struct FileOptions { +mut: +unknown_fields []vproto.UnknownField +pub mut: +java_package string +has_java_package bool +java_outer_classname string +has_java_outer_classname bool +java_multiple_files bool +has_java_multiple_files bool +java_generate_equals_and_hash bool +has_java_generate_equals_and_hash bool +java_string_check_utf8 bool +has_java_string_check_utf8 bool +optimize_for FileOptionsOptimizeMode +has_optimize_for bool +go_package string +has_go_package bool +cc_generic_services bool +has_cc_generic_services bool +java_generic_services bool +has_java_generic_services bool +py_generic_services bool +has_py_generic_services bool +deprecated bool +has_deprecated bool +uninterpreted_option []UninterpretedOption +} +pub fn (o &FileOptions) pack() []byte { +mut res := []byte{} +if o.has_java_package { +res << vproto.pack_string_field(o.java_package, 1) +} + +if o.has_java_outer_classname { +res << vproto.pack_string_field(o.java_outer_classname, 8) +} + +if o.has_java_multiple_files { +res << vproto.pack_bool_field(o.java_multiple_files, 10) +} + +if o.has_java_generate_equals_and_hash { +res << vproto.pack_bool_field(o.java_generate_equals_and_hash, 20) +} + +if o.has_java_string_check_utf8 { +res << vproto.pack_bool_field(o.java_string_check_utf8, 27) +} + +if o.has_optimize_for { +res << zzz_vproto_internal_pack_fileoptionsoptimizemode(o.optimize_for, 9) +} + +if o.has_go_package { +res << vproto.pack_string_field(o.go_package, 11) +} + +if o.has_cc_generic_services { +res << vproto.pack_bool_field(o.cc_generic_services, 16) +} + +if o.has_java_generic_services { +res << vproto.pack_bool_field(o.java_generic_services, 17) +} + +if o.has_py_generic_services { +res << vproto.pack_bool_field(o.py_generic_services, 18) +} + +if o.has_deprecated { +res << vproto.pack_bool_field(o.deprecated, 23) +} + +// [packed=false] +for _, x in o.uninterpreted_option { +res << zzz_vproto_internal_pack_uninterpretedoption(x, 999) +} + +return res +} + +pub fn fileoptions_unpack(buf []byte) ?FileOptions { +mut res := FileOptions{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_java_package = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.java_package = v +i = ii +} + +8 { +res.has_java_outer_classname = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.java_outer_classname = v +i = ii +} + +10 { +res.has_java_multiple_files = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.java_multiple_files = v +i = ii +} + +20 { +res.has_java_generate_equals_and_hash = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.java_generate_equals_and_hash = v +i = ii +} + +27 { +res.has_java_string_check_utf8 = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.java_string_check_utf8 = v +i = ii +} + +9 { +res.has_optimize_for = true +ii, v := zzz_vproto_internal_unpack_fileoptionsoptimizemode(cur_buf, tag_wiretype.wire_type)? +res.optimize_for = v +i = ii +} + +11 { +res.has_go_package = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.go_package = v +i = ii +} + +16 { +res.has_cc_generic_services = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.cc_generic_services = v +i = ii +} + +17 { +res.has_java_generic_services = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.java_generic_services = v +i = ii +} + +18 { +res.has_py_generic_services = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.py_generic_services = v +i = ii +} + +23 { +res.has_deprecated = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated = v +i = ii +} + +999 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_uninterpretedoption(cur_buf, tag_wiretype.wire_type)? +res.uninterpreted_option << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_fileoptions() FileOptions { +return FileOptions{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_fileoptions(o FileOptions, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_fileoptions(buf []byte, tag_wiretype vproto.WireType) ?(int, FileOptions) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := fileoptions_unpack(v)? +return i, unpacked +} +pub struct MessageOptions { +mut: +unknown_fields []vproto.UnknownField +pub mut: +message_set_wire_format bool +has_message_set_wire_format bool +no_standard_descriptor_accessor bool +has_no_standard_descriptor_accessor bool +deprecated bool +has_deprecated bool +uninterpreted_option []UninterpretedOption +} +pub fn (o &MessageOptions) pack() []byte { +mut res := []byte{} +if o.has_message_set_wire_format { +res << vproto.pack_bool_field(o.message_set_wire_format, 1) +} + +if o.has_no_standard_descriptor_accessor { +res << vproto.pack_bool_field(o.no_standard_descriptor_accessor, 2) +} + +if o.has_deprecated { +res << vproto.pack_bool_field(o.deprecated, 3) +} + +// [packed=false] +for _, x in o.uninterpreted_option { +res << zzz_vproto_internal_pack_uninterpretedoption(x, 999) +} + +return res +} + +pub fn messageoptions_unpack(buf []byte) ?MessageOptions { +mut res := MessageOptions{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_message_set_wire_format = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.message_set_wire_format = v +i = ii +} + +2 { +res.has_no_standard_descriptor_accessor = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.no_standard_descriptor_accessor = v +i = ii +} + +3 { +res.has_deprecated = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated = v +i = ii +} + +999 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_uninterpretedoption(cur_buf, tag_wiretype.wire_type)? +res.uninterpreted_option << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_messageoptions() MessageOptions { +return MessageOptions{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_messageoptions(o MessageOptions, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_messageoptions(buf []byte, tag_wiretype vproto.WireType) ?(int, MessageOptions) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := messageoptions_unpack(v)? +return i, unpacked +} +[_allow_multiple_values] +enum FieldOptionsCType { +string = 0 +cord = 1 +string_piece = 2 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_fieldoptionsctype(e FieldOptionsCType, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_fieldoptionsctype(buf []byte, tag_wiretype vproto.WireType) ?(int, FieldOptionsCType) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, FieldOptionsCType(v) +} +pub struct FieldOptions { +mut: +unknown_fields []vproto.UnknownField +pub mut: +ctype FieldOptionsCType +has_ctype bool +packed bool +has_packed bool +lazy bool +has_lazy bool +deprecated bool +has_deprecated bool +experimental_map_key string +has_experimental_map_key bool +weak bool +has_weak bool +uninterpreted_option []UninterpretedOption +} +pub fn (o &FieldOptions) pack() []byte { +mut res := []byte{} +if o.has_ctype { +res << zzz_vproto_internal_pack_fieldoptionsctype(o.ctype, 1) +} + +if o.has_packed { +res << vproto.pack_bool_field(o.packed, 2) +} + +if o.has_lazy { +res << vproto.pack_bool_field(o.lazy, 5) +} + +if o.has_deprecated { +res << vproto.pack_bool_field(o.deprecated, 3) +} + +if o.has_experimental_map_key { +res << vproto.pack_string_field(o.experimental_map_key, 9) +} + +if o.has_weak { +res << vproto.pack_bool_field(o.weak, 10) +} + +// [packed=false] +for _, x in o.uninterpreted_option { +res << zzz_vproto_internal_pack_uninterpretedoption(x, 999) +} + +return res +} + +pub fn fieldoptions_unpack(buf []byte) ?FieldOptions { +mut res := FieldOptions{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_ctype = true +ii, v := zzz_vproto_internal_unpack_fieldoptionsctype(cur_buf, tag_wiretype.wire_type)? +res.ctype = v +i = ii +} + +2 { +res.has_packed = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.packed = v +i = ii +} + +5 { +res.has_lazy = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.lazy = v +i = ii +} + +3 { +res.has_deprecated = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated = v +i = ii +} + +9 { +res.has_experimental_map_key = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.experimental_map_key = v +i = ii +} + +10 { +res.has_weak = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.weak = v +i = ii +} + +999 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_uninterpretedoption(cur_buf, tag_wiretype.wire_type)? +res.uninterpreted_option << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_fieldoptions() FieldOptions { +return FieldOptions{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_fieldoptions(o FieldOptions, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_fieldoptions(buf []byte, tag_wiretype vproto.WireType) ?(int, FieldOptions) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := fieldoptions_unpack(v)? +return i, unpacked +} +pub struct EnumOptions { +mut: +unknown_fields []vproto.UnknownField +pub mut: +allow_alias bool +has_allow_alias bool +deprecated bool +has_deprecated bool +uninterpreted_option []UninterpretedOption +} +pub fn (o &EnumOptions) pack() []byte { +mut res := []byte{} +if o.has_allow_alias { +res << vproto.pack_bool_field(o.allow_alias, 2) +} + +if o.has_deprecated { +res << vproto.pack_bool_field(o.deprecated, 3) +} + +// [packed=false] +for _, x in o.uninterpreted_option { +res << zzz_vproto_internal_pack_uninterpretedoption(x, 999) +} + +return res +} + +pub fn enumoptions_unpack(buf []byte) ?EnumOptions { +mut res := EnumOptions{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +2 { +res.has_allow_alias = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.allow_alias = v +i = ii +} + +3 { +res.has_deprecated = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated = v +i = ii +} + +999 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_uninterpretedoption(cur_buf, tag_wiretype.wire_type)? +res.uninterpreted_option << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_enumoptions() EnumOptions { +return EnumOptions{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_enumoptions(o EnumOptions, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_enumoptions(buf []byte, tag_wiretype vproto.WireType) ?(int, EnumOptions) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := enumoptions_unpack(v)? +return i, unpacked +} +pub struct EnumValueOptions { +mut: +unknown_fields []vproto.UnknownField +pub mut: +deprecated bool +has_deprecated bool +uninterpreted_option []UninterpretedOption +} +pub fn (o &EnumValueOptions) pack() []byte { +mut res := []byte{} +if o.has_deprecated { +res << vproto.pack_bool_field(o.deprecated, 1) +} + +// [packed=false] +for _, x in o.uninterpreted_option { +res << zzz_vproto_internal_pack_uninterpretedoption(x, 999) +} + +return res +} + +pub fn enumvalueoptions_unpack(buf []byte) ?EnumValueOptions { +mut res := EnumValueOptions{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_deprecated = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated = v +i = ii +} + +999 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_uninterpretedoption(cur_buf, tag_wiretype.wire_type)? +res.uninterpreted_option << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_enumvalueoptions() EnumValueOptions { +return EnumValueOptions{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_enumvalueoptions(o EnumValueOptions, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_enumvalueoptions(buf []byte, tag_wiretype vproto.WireType) ?(int, EnumValueOptions) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := enumvalueoptions_unpack(v)? +return i, unpacked +} +pub struct ServiceOptions { +mut: +unknown_fields []vproto.UnknownField +pub mut: +deprecated bool +has_deprecated bool +uninterpreted_option []UninterpretedOption +} +pub fn (o &ServiceOptions) pack() []byte { +mut res := []byte{} +if o.has_deprecated { +res << vproto.pack_bool_field(o.deprecated, 33) +} + +// [packed=false] +for _, x in o.uninterpreted_option { +res << zzz_vproto_internal_pack_uninterpretedoption(x, 999) +} + +return res +} + +pub fn serviceoptions_unpack(buf []byte) ?ServiceOptions { +mut res := ServiceOptions{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +33 { +res.has_deprecated = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated = v +i = ii +} + +999 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_uninterpretedoption(cur_buf, tag_wiretype.wire_type)? +res.uninterpreted_option << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_serviceoptions() ServiceOptions { +return ServiceOptions{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_serviceoptions(o ServiceOptions, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_serviceoptions(buf []byte, tag_wiretype vproto.WireType) ?(int, ServiceOptions) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := serviceoptions_unpack(v)? +return i, unpacked +} +pub struct MethodOptions { +mut: +unknown_fields []vproto.UnknownField +pub mut: +deprecated bool +has_deprecated bool +uninterpreted_option []UninterpretedOption +} +pub fn (o &MethodOptions) pack() []byte { +mut res := []byte{} +if o.has_deprecated { +res << vproto.pack_bool_field(o.deprecated, 33) +} + +// [packed=false] +for _, x in o.uninterpreted_option { +res << zzz_vproto_internal_pack_uninterpretedoption(x, 999) +} + +return res +} + +pub fn methodoptions_unpack(buf []byte) ?MethodOptions { +mut res := MethodOptions{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +33 { +res.has_deprecated = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated = v +i = ii +} + +999 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_uninterpretedoption(cur_buf, tag_wiretype.wire_type)? +res.uninterpreted_option << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_methodoptions() MethodOptions { +return MethodOptions{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_methodoptions(o MethodOptions, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_methodoptions(buf []byte, tag_wiretype vproto.WireType) ?(int, MethodOptions) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := methodoptions_unpack(v)? +return i, unpacked +} +pub struct UninterpretedOptionNamePart { +mut: +unknown_fields []vproto.UnknownField +pub mut: +name_part string +is_extension bool +} +pub fn (o &UninterpretedOptionNamePart) pack() []byte { +mut res := []byte{} +res << vproto.pack_string_field(o.name_part, 1) + +res << vproto.pack_bool_field(o.is_extension, 2) + +return res +} + +pub fn uninterpretedoptionnamepart_unpack(buf []byte) ?UninterpretedOptionNamePart { +mut res := UninterpretedOptionNamePart{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name_part = v +i = ii +} + +2 { +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_extension = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_uninterpretedoptionnamepart() UninterpretedOptionNamePart { +return UninterpretedOptionNamePart{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_uninterpretedoptionnamepart(o UninterpretedOptionNamePart, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_uninterpretedoptionnamepart(buf []byte, tag_wiretype vproto.WireType) ?(int, UninterpretedOptionNamePart) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := uninterpretedoptionnamepart_unpack(v)? +return i, unpacked +} +pub struct UninterpretedOption { +mut: +unknown_fields []vproto.UnknownField +pub mut: +name []UninterpretedOptionNamePart +identifier_value string +has_identifier_value bool +positive_int_value u64 +has_positive_int_value bool +negative_int_value i64 +has_negative_int_value bool +double_value f64 +has_double_value bool +string_value []byte +has_string_value bool +aggregate_value string +has_aggregate_value bool +} +pub fn (o &UninterpretedOption) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.name { +res << zzz_vproto_internal_pack_uninterpretedoptionnamepart(x, 2) +} + +if o.has_identifier_value { +res << vproto.pack_string_field(o.identifier_value, 3) +} + +if o.has_positive_int_value { +res << vproto.pack_uint64_field(o.positive_int_value, 4) +} + +if o.has_negative_int_value { +res << vproto.pack_int64_field(o.negative_int_value, 5) +} + +if o.has_double_value { +res << vproto.pack_double_field(o.double_value, 6) +} + +if o.has_string_value { +res << vproto.pack_bytes_field(o.string_value, 7) +} + +if o.has_aggregate_value { +res << vproto.pack_string_field(o.aggregate_value, 8) +} + +return res +} + +pub fn uninterpretedoption_unpack(buf []byte) ?UninterpretedOption { +mut res := UninterpretedOption{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_uninterpretedoptionnamepart(cur_buf, tag_wiretype.wire_type)? +res.name << v +i = ii +} + +3 { +res.has_identifier_value = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.identifier_value = v +i = ii +} + +4 { +res.has_positive_int_value = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.positive_int_value = v +i = ii +} + +5 { +res.has_negative_int_value = true +ii, v := vproto.unpack_int64_field(cur_buf, tag_wiretype.wire_type)? +res.negative_int_value = v +i = ii +} + +6 { +res.has_double_value = true +ii, v := vproto.unpack_double_field(cur_buf, tag_wiretype.wire_type)? +res.double_value = v +i = ii +} + +7 { +res.has_string_value = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.string_value = v +i = ii +} + +8 { +res.has_aggregate_value = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.aggregate_value = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_uninterpretedoption() UninterpretedOption { +return UninterpretedOption{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_uninterpretedoption(o UninterpretedOption, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_uninterpretedoption(buf []byte, tag_wiretype vproto.WireType) ?(int, UninterpretedOption) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := uninterpretedoption_unpack(v)? +return i, unpacked +} +pub struct SourceCodeInfoLocation { +mut: +unknown_fields []vproto.UnknownField +pub mut: +path []int +span []int +leading_comments string +has_leading_comments bool +trailing_comments string +has_trailing_comments bool +} +pub fn (o &SourceCodeInfoLocation) pack() []byte { +mut res := []byte{} +// [packed=true] +res << vproto.pack_int32_field_packed(o.path, 1) + +// [packed=true] +res << vproto.pack_int32_field_packed(o.span, 2) + +if o.has_leading_comments { +res << vproto.pack_string_field(o.leading_comments, 3) +} + +if o.has_trailing_comments { +res << vproto.pack_string_field(o.trailing_comments, 4) +} + +return res +} + +pub fn sourcecodeinfolocation_unpack(buf []byte) ?SourceCodeInfoLocation { +mut res := SourceCodeInfoLocation{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=true] +ii, v := vproto.unpack_int32_field_packed(cur_buf, tag_wiretype.wire_type) ? +res.path << v +i = ii +} + +2 { +// [packed=true] +ii, v := vproto.unpack_int32_field_packed(cur_buf, tag_wiretype.wire_type) ? +res.span << v +i = ii +} + +3 { +res.has_leading_comments = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.leading_comments = v +i = ii +} + +4 { +res.has_trailing_comments = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.trailing_comments = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_sourcecodeinfolocation() SourceCodeInfoLocation { +return SourceCodeInfoLocation{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_sourcecodeinfolocation(o SourceCodeInfoLocation, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_sourcecodeinfolocation(buf []byte, tag_wiretype vproto.WireType) ?(int, SourceCodeInfoLocation) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := sourcecodeinfolocation_unpack(v)? +return i, unpacked +} +pub struct SourceCodeInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +location []SourceCodeInfoLocation +} +pub fn (o &SourceCodeInfo) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.location { +res << zzz_vproto_internal_pack_sourcecodeinfolocation(x, 1) +} + +return res +} + +pub fn sourcecodeinfo_unpack(buf []byte) ?SourceCodeInfo { +mut res := SourceCodeInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_sourcecodeinfolocation(cur_buf, tag_wiretype.wire_type)? +res.location << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_sourcecodeinfo() SourceCodeInfo { +return SourceCodeInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_sourcecodeinfo(o SourceCodeInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_sourcecodeinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, SourceCodeInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := sourcecodeinfo_unpack(v)? +return i, unpacked +} diff --git a/proto/htmlmessages_pb.v b/proto/htmlmessages_pb.v new file mode 100644 index 0000000..d283ceb --- /dev/null +++ b/proto/htmlmessages_pb.v @@ -0,0 +1,12564 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +[_allow_multiple_values] +enum EJsregisterMethodType { +k_ejsregistermethodtype_invalid = 0 +k_ejsregistermethodtype_function = 1 +k_ejsregistermethodtype_callback = 2 +k_ejsregistermethodtype_promise = 3 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_ejsregistermethodtype(e EJsregisterMethodType, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_ejsregistermethodtype(buf []byte, tag_wiretype vproto.WireType) ?(int, EJsregisterMethodType) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EJsregisterMethodType(v) +} +pub struct CMsgKeyUp { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +keycode u32 +has_keycode bool +modifiers u32 +has_modifiers bool +nativekeycode u32 +has_nativekeycode bool +} +pub fn (o &CMsgKeyUp) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_keycode { +res << vproto.pack_uint32_field(o.keycode, 2) +} + +if o.has_modifiers { +res << vproto.pack_uint32_field(o.modifiers, 3) +} + +if o.has_nativekeycode { +res << vproto.pack_uint32_field(o.nativekeycode, 4) +} + +return res +} + +pub fn cmsgkeyup_unpack(buf []byte) ?CMsgKeyUp { +mut res := CMsgKeyUp{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_keycode = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.keycode = v +i = ii +} + +3 { +res.has_modifiers = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.modifiers = v +i = ii +} + +4 { +res.has_nativekeycode = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.nativekeycode = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgkeyup() CMsgKeyUp { +return CMsgKeyUp{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgkeyup(o CMsgKeyUp, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgkeyup(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgKeyUp) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgkeyup_unpack(v)? +return i, unpacked +} +pub struct CMsgKeyDown { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +keycode u32 +has_keycode bool +modifiers u32 +has_modifiers bool +is_system_key bool +has_is_system_key bool +nativekeycode u32 +has_nativekeycode bool +} +pub fn (o &CMsgKeyDown) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_keycode { +res << vproto.pack_uint32_field(o.keycode, 2) +} + +if o.has_modifiers { +res << vproto.pack_uint32_field(o.modifiers, 3) +} + +if o.has_is_system_key { +res << vproto.pack_bool_field(o.is_system_key, 4) +} + +if o.has_nativekeycode { +res << vproto.pack_uint32_field(o.nativekeycode, 5) +} + +return res +} + +pub fn cmsgkeydown_unpack(buf []byte) ?CMsgKeyDown { +mut res := CMsgKeyDown{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_keycode = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.keycode = v +i = ii +} + +3 { +res.has_modifiers = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.modifiers = v +i = ii +} + +4 { +res.has_is_system_key = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_system_key = v +i = ii +} + +5 { +res.has_nativekeycode = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.nativekeycode = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgkeydown() CMsgKeyDown { +return CMsgKeyDown{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgkeydown(o CMsgKeyDown, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgkeydown(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgKeyDown) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgkeydown_unpack(v)? +return i, unpacked +} +pub struct CMsgKeyChar { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +unichar u32 +has_unichar bool +modifiers u32 +has_modifiers bool +keycode u32 +has_keycode bool +nativekeycode u32 +has_nativekeycode bool +} +pub fn (o &CMsgKeyChar) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_unichar { +res << vproto.pack_uint32_field(o.unichar, 2) +} + +if o.has_modifiers { +res << vproto.pack_uint32_field(o.modifiers, 3) +} + +if o.has_keycode { +res << vproto.pack_uint32_field(o.keycode, 4) +} + +if o.has_nativekeycode { +res << vproto.pack_uint32_field(o.nativekeycode, 5) +} + +return res +} + +pub fn cmsgkeychar_unpack(buf []byte) ?CMsgKeyChar { +mut res := CMsgKeyChar{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_unichar = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.unichar = v +i = ii +} + +3 { +res.has_modifiers = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.modifiers = v +i = ii +} + +4 { +res.has_keycode = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.keycode = v +i = ii +} + +5 { +res.has_nativekeycode = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.nativekeycode = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgkeychar() CMsgKeyChar { +return CMsgKeyChar{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgkeychar(o CMsgKeyChar, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgkeychar(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgKeyChar) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgkeychar_unpack(v)? +return i, unpacked +} +pub struct CMsgMouseDown { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +mouse_button u32 +has_mouse_button bool +modifiers u32 +has_modifiers bool +} +pub fn (o &CMsgMouseDown) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_mouse_button { +res << vproto.pack_uint32_field(o.mouse_button, 2) +} + +if o.has_modifiers { +res << vproto.pack_uint32_field(o.modifiers, 3) +} + +return res +} + +pub fn cmsgmousedown_unpack(buf []byte) ?CMsgMouseDown { +mut res := CMsgMouseDown{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_mouse_button = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.mouse_button = v +i = ii +} + +3 { +res.has_modifiers = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.modifiers = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgmousedown() CMsgMouseDown { +return CMsgMouseDown{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgmousedown(o CMsgMouseDown, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgmousedown(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgMouseDown) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgmousedown_unpack(v)? +return i, unpacked +} +pub struct CMsgMouseUp { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +mouse_button u32 +has_mouse_button bool +modifiers u32 +has_modifiers bool +is_off_panel bool +has_is_off_panel bool +x int +has_x bool +y int +has_y bool +} +pub fn (o &CMsgMouseUp) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_mouse_button { +res << vproto.pack_uint32_field(o.mouse_button, 2) +} + +if o.has_modifiers { +res << vproto.pack_uint32_field(o.modifiers, 3) +} + +if o.has_is_off_panel { +res << vproto.pack_bool_field(o.is_off_panel, 4) +} + +if o.has_x { +res << vproto.pack_int32_field(o.x, 5) +} + +if o.has_y { +res << vproto.pack_int32_field(o.y, 6) +} + +return res +} + +pub fn cmsgmouseup_unpack(buf []byte) ?CMsgMouseUp { +mut res := CMsgMouseUp{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_mouse_button = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.mouse_button = v +i = ii +} + +3 { +res.has_modifiers = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.modifiers = v +i = ii +} + +4 { +res.has_is_off_panel = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_off_panel = v +i = ii +} + +5 { +res.has_x = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.x = v +i = ii +} + +6 { +res.has_y = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.y = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgmouseup() CMsgMouseUp { +return CMsgMouseUp{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgmouseup(o CMsgMouseUp, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgmouseup(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgMouseUp) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgmouseup_unpack(v)? +return i, unpacked +} +pub struct CMsgMouseDblClick { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +mouse_button u32 +has_mouse_button bool +modifiers u32 +has_modifiers bool +} +pub fn (o &CMsgMouseDblClick) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_mouse_button { +res << vproto.pack_uint32_field(o.mouse_button, 2) +} + +if o.has_modifiers { +res << vproto.pack_uint32_field(o.modifiers, 3) +} + +return res +} + +pub fn cmsgmousedblclick_unpack(buf []byte) ?CMsgMouseDblClick { +mut res := CMsgMouseDblClick{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_mouse_button = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.mouse_button = v +i = ii +} + +3 { +res.has_modifiers = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.modifiers = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgmousedblclick() CMsgMouseDblClick { +return CMsgMouseDblClick{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgmousedblclick(o CMsgMouseDblClick, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgmousedblclick(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgMouseDblClick) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgmousedblclick_unpack(v)? +return i, unpacked +} +pub struct CMsgMouseWheel { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +deltax int +has_deltax bool +deltay int +has_deltay bool +modifiers u32 +has_modifiers bool +} +pub fn (o &CMsgMouseWheel) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_deltax { +res << vproto.pack_int32_field(o.deltax, 2) +} + +if o.has_deltay { +res << vproto.pack_int32_field(o.deltay, 3) +} + +if o.has_modifiers { +res << vproto.pack_uint32_field(o.modifiers, 4) +} + +return res +} + +pub fn cmsgmousewheel_unpack(buf []byte) ?CMsgMouseWheel { +mut res := CMsgMouseWheel{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_deltax = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.deltax = v +i = ii +} + +3 { +res.has_deltay = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.deltay = v +i = ii +} + +4 { +res.has_modifiers = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.modifiers = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgmousewheel() CMsgMouseWheel { +return CMsgMouseWheel{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgmousewheel(o CMsgMouseWheel, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgmousewheel(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgMouseWheel) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgmousewheel_unpack(v)? +return i, unpacked +} +pub struct CMsgMouseMove { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +x int +has_x bool +y int +has_y bool +modifiers u32 +has_modifiers bool +} +pub fn (o &CMsgMouseMove) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_x { +res << vproto.pack_int32_field(o.x, 2) +} + +if o.has_y { +res << vproto.pack_int32_field(o.y, 3) +} + +if o.has_modifiers { +res << vproto.pack_uint32_field(o.modifiers, 4) +} + +return res +} + +pub fn cmsgmousemove_unpack(buf []byte) ?CMsgMouseMove { +mut res := CMsgMouseMove{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_x = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.x = v +i = ii +} + +3 { +res.has_y = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.y = v +i = ii +} + +4 { +res.has_modifiers = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.modifiers = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgmousemove() CMsgMouseMove { +return CMsgMouseMove{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgmousemove(o CMsgMouseMove, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgmousemove(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgMouseMove) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgmousemove_unpack(v)? +return i, unpacked +} +pub struct CMsgMouseLeave { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgMouseLeave) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgmouseleave_unpack(buf []byte) ?CMsgMouseLeave { +mut res := CMsgMouseLeave{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgmouseleave() CMsgMouseLeave { +return CMsgMouseLeave{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgmouseleave(o CMsgMouseLeave, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgmouseleave(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgMouseLeave) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgmouseleave_unpack(v)? +return i, unpacked +} +pub struct CMsgBrowserCreate { +mut: +unknown_fields []vproto.UnknownField +pub mut: +request_id u32 +has_request_id bool +useragent string +has_useragent bool +user_css string +has_user_css bool +native_dropdowns bool +has_native_dropdowns bool +dpi_scaling f32 +has_dpi_scaling bool +offscreen bool +has_offscreen bool +initial_width u32 +has_initial_width bool +initial_height u32 +has_initial_height bool +window_icon string +has_window_icon bool +borderless bool +has_borderless bool +vroverlay_key string +has_vroverlay_key bool +browser_type u32 +has_browser_type bool +initial_top int +has_initial_top bool +initial_left int +has_initial_left bool +only_allow_trusted_popups bool +has_only_allow_trusted_popups bool +initial_url string +has_initial_url bool +hwnd_parent u64 +has_hwnd_parent bool +} +pub fn (o &CMsgBrowserCreate) pack() []byte { +mut res := []byte{} +if o.has_request_id { +res << vproto.pack_uint32_field(o.request_id, 1) +} + +if o.has_useragent { +res << vproto.pack_string_field(o.useragent, 3) +} + +if o.has_user_css { +res << vproto.pack_string_field(o.user_css, 5) +} + +if o.has_native_dropdowns { +res << vproto.pack_bool_field(o.native_dropdowns, 6) +} + +if o.has_dpi_scaling { +res << vproto.pack_float_field(o.dpi_scaling, 7) +} + +if o.has_offscreen { +res << vproto.pack_bool_field(o.offscreen, 8) +} + +if o.has_initial_width { +res << vproto.pack_uint32_field(o.initial_width, 9) +} + +if o.has_initial_height { +res << vproto.pack_uint32_field(o.initial_height, 10) +} + +if o.has_window_icon { +res << vproto.pack_string_field(o.window_icon, 11) +} + +if o.has_borderless { +res << vproto.pack_bool_field(o.borderless, 12) +} + +if o.has_vroverlay_key { +res << vproto.pack_string_field(o.vroverlay_key, 13) +} + +if o.has_browser_type { +res << vproto.pack_uint32_field(o.browser_type, 14) +} + +if o.has_initial_top { +res << vproto.pack_int32_field(o.initial_top, 15) +} + +if o.has_initial_left { +res << vproto.pack_int32_field(o.initial_left, 16) +} + +if o.has_only_allow_trusted_popups { +res << vproto.pack_bool_field(o.only_allow_trusted_popups, 17) +} + +if o.has_initial_url { +res << vproto.pack_string_field(o.initial_url, 18) +} + +if o.has_hwnd_parent { +res << vproto.pack_64bit_field(o.hwnd_parent, 19) +} + +return res +} + +pub fn cmsgbrowsercreate_unpack(buf []byte) ?CMsgBrowserCreate { +mut res := CMsgBrowserCreate{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_request_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.request_id = v +i = ii +} + +3 { +res.has_useragent = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.useragent = v +i = ii +} + +5 { +res.has_user_css = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.user_css = v +i = ii +} + +6 { +res.has_native_dropdowns = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.native_dropdowns = v +i = ii +} + +7 { +res.has_dpi_scaling = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.dpi_scaling = v +i = ii +} + +8 { +res.has_offscreen = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.offscreen = v +i = ii +} + +9 { +res.has_initial_width = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.initial_width = v +i = ii +} + +10 { +res.has_initial_height = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.initial_height = v +i = ii +} + +11 { +res.has_window_icon = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.window_icon = v +i = ii +} + +12 { +res.has_borderless = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.borderless = v +i = ii +} + +13 { +res.has_vroverlay_key = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.vroverlay_key = v +i = ii +} + +14 { +res.has_browser_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_type = v +i = ii +} + +15 { +res.has_initial_top = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.initial_top = v +i = ii +} + +16 { +res.has_initial_left = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.initial_left = v +i = ii +} + +17 { +res.has_only_allow_trusted_popups = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.only_allow_trusted_popups = v +i = ii +} + +18 { +res.has_initial_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.initial_url = v +i = ii +} + +19 { +res.has_hwnd_parent = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.hwnd_parent = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgbrowsercreate() CMsgBrowserCreate { +return CMsgBrowserCreate{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgbrowsercreate(o CMsgBrowserCreate, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgbrowsercreate(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgBrowserCreate) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgbrowsercreate_unpack(v)? +return i, unpacked +} +pub struct CMsgBrowserCreateResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +request_id u32 +has_request_id bool +} +pub fn (o &CMsgBrowserCreateResponse) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_request_id { +res << vproto.pack_uint32_field(o.request_id, 2) +} + +return res +} + +pub fn cmsgbrowsercreateresponse_unpack(buf []byte) ?CMsgBrowserCreateResponse { +mut res := CMsgBrowserCreateResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_request_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.request_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgbrowsercreateresponse() CMsgBrowserCreateResponse { +return CMsgBrowserCreateResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgbrowsercreateresponse(o CMsgBrowserCreateResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgbrowsercreateresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgBrowserCreateResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgbrowsercreateresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgBrowserRemove { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgBrowserRemove) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgbrowserremove_unpack(buf []byte) ?CMsgBrowserRemove { +mut res := CMsgBrowserRemove{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgbrowserremove() CMsgBrowserRemove { +return CMsgBrowserRemove{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgbrowserremove(o CMsgBrowserRemove, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgbrowserremove(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgBrowserRemove) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgbrowserremove_unpack(v)? +return i, unpacked +} +pub struct CMsgSetLocalFileRequestMappingAdditionalRoute { +mut: +unknown_fields []vproto.UnknownField +pub mut: +relative_url string +has_relative_url bool +local_path string +has_local_path bool +allowed_extensions string +has_allowed_extensions bool +} +pub fn (o &CMsgSetLocalFileRequestMappingAdditionalRoute) pack() []byte { +mut res := []byte{} +if o.has_relative_url { +res << vproto.pack_string_field(o.relative_url, 1) +} + +if o.has_local_path { +res << vproto.pack_string_field(o.local_path, 2) +} + +if o.has_allowed_extensions { +res << vproto.pack_string_field(o.allowed_extensions, 3) +} + +return res +} + +pub fn cmsgsetlocalfilerequestmappingadditionalroute_unpack(buf []byte) ?CMsgSetLocalFileRequestMappingAdditionalRoute { +mut res := CMsgSetLocalFileRequestMappingAdditionalRoute{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_relative_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.relative_url = v +i = ii +} + +2 { +res.has_local_path = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.local_path = v +i = ii +} + +3 { +res.has_allowed_extensions = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.allowed_extensions = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsetlocalfilerequestmappingadditionalroute() CMsgSetLocalFileRequestMappingAdditionalRoute { +return CMsgSetLocalFileRequestMappingAdditionalRoute{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsetlocalfilerequestmappingadditionalroute(o CMsgSetLocalFileRequestMappingAdditionalRoute, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsetlocalfilerequestmappingadditionalroute(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSetLocalFileRequestMappingAdditionalRoute) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsetlocalfilerequestmappingadditionalroute_unpack(v)? +return i, unpacked +} +pub struct CMsgSetLocalFileRequestMapping { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +request_url string +has_request_url bool +default_local_path string +has_default_local_path bool +routes []CMsgSetLocalFileRequestMappingAdditionalRoute +} +pub fn (o &CMsgSetLocalFileRequestMapping) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_request_url { +res << vproto.pack_string_field(o.request_url, 2) +} + +if o.has_default_local_path { +res << vproto.pack_string_field(o.default_local_path, 3) +} + +// [packed=false] +for _, x in o.routes { +res << zzz_vproto_internal_pack_cmsgsetlocalfilerequestmappingadditionalroute(x, 4) +} + +return res +} + +pub fn cmsgsetlocalfilerequestmapping_unpack(buf []byte) ?CMsgSetLocalFileRequestMapping { +mut res := CMsgSetLocalFileRequestMapping{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_request_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.request_url = v +i = ii +} + +3 { +res.has_default_local_path = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.default_local_path = v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgsetlocalfilerequestmappingadditionalroute(cur_buf, tag_wiretype.wire_type)? +res.routes << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsetlocalfilerequestmapping() CMsgSetLocalFileRequestMapping { +return CMsgSetLocalFileRequestMapping{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsetlocalfilerequestmapping(o CMsgSetLocalFileRequestMapping, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsetlocalfilerequestmapping(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSetLocalFileRequestMapping) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsetlocalfilerequestmapping_unpack(v)? +return i, unpacked +} +pub struct CMsgBrowserErrorStrings { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +title string +has_title bool +header string +has_header bool +cache_miss string +has_cache_miss bool +bad_url string +has_bad_url bool +connection_problem string +has_connection_problem bool +proxy_problem string +has_proxy_problem bool +unknown string +has_unknown bool +} +pub fn (o &CMsgBrowserErrorStrings) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_title { +res << vproto.pack_string_field(o.title, 2) +} + +if o.has_header { +res << vproto.pack_string_field(o.header, 3) +} + +if o.has_cache_miss { +res << vproto.pack_string_field(o.cache_miss, 4) +} + +if o.has_bad_url { +res << vproto.pack_string_field(o.bad_url, 5) +} + +if o.has_connection_problem { +res << vproto.pack_string_field(o.connection_problem, 6) +} + +if o.has_proxy_problem { +res << vproto.pack_string_field(o.proxy_problem, 7) +} + +if o.has_unknown { +res << vproto.pack_string_field(o.unknown, 8) +} + +return res +} + +pub fn cmsgbrowsererrorstrings_unpack(buf []byte) ?CMsgBrowserErrorStrings { +mut res := CMsgBrowserErrorStrings{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_title = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.title = v +i = ii +} + +3 { +res.has_header = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.header = v +i = ii +} + +4 { +res.has_cache_miss = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.cache_miss = v +i = ii +} + +5 { +res.has_bad_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.bad_url = v +i = ii +} + +6 { +res.has_connection_problem = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.connection_problem = v +i = ii +} + +7 { +res.has_proxy_problem = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.proxy_problem = v +i = ii +} + +8 { +res.has_unknown = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.unknown = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgbrowsererrorstrings() CMsgBrowserErrorStrings { +return CMsgBrowserErrorStrings{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgbrowsererrorstrings(o CMsgBrowserErrorStrings, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgbrowsererrorstrings(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgBrowserErrorStrings) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgbrowsererrorstrings_unpack(v)? +return i, unpacked +} +pub struct CMsgBrowserSize { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +width u32 +has_width bool +height u32 +has_height bool +} +pub fn (o &CMsgBrowserSize) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_width { +res << vproto.pack_uint32_field(o.width, 2) +} + +if o.has_height { +res << vproto.pack_uint32_field(o.height, 3) +} + +return res +} + +pub fn cmsgbrowsersize_unpack(buf []byte) ?CMsgBrowserSize { +mut res := CMsgBrowserSize{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_width = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.width = v +i = ii +} + +3 { +res.has_height = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.height = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgbrowsersize() CMsgBrowserSize { +return CMsgBrowserSize{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgbrowsersize(o CMsgBrowserSize, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgbrowsersize(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgBrowserSize) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgbrowsersize_unpack(v)? +return i, unpacked +} +pub struct CMsgBrowserSetMinSize { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +width u32 +has_width bool +height u32 +has_height bool +} +pub fn (o &CMsgBrowserSetMinSize) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_width { +res << vproto.pack_uint32_field(o.width, 2) +} + +if o.has_height { +res << vproto.pack_uint32_field(o.height, 3) +} + +return res +} + +pub fn cmsgbrowsersetminsize_unpack(buf []byte) ?CMsgBrowserSetMinSize { +mut res := CMsgBrowserSetMinSize{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_width = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.width = v +i = ii +} + +3 { +res.has_height = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.height = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgbrowsersetminsize() CMsgBrowserSetMinSize { +return CMsgBrowserSetMinSize{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgbrowsersetminsize(o CMsgBrowserSetMinSize, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgbrowsersetminsize(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgBrowserSetMinSize) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgbrowsersetminsize_unpack(v)? +return i, unpacked +} +pub struct CMsgBrowserPosition { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +x int +has_x bool +y int +has_y bool +x_local int +has_x_local bool +y_local int +has_y_local bool +} +pub fn (o &CMsgBrowserPosition) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_x { +res << vproto.pack_int32_field(o.x, 2) +} + +if o.has_y { +res << vproto.pack_int32_field(o.y, 3) +} + +if o.has_x_local { +res << vproto.pack_int32_field(o.x_local, 4) +} + +if o.has_y_local { +res << vproto.pack_int32_field(o.y_local, 5) +} + +return res +} + +pub fn cmsgbrowserposition_unpack(buf []byte) ?CMsgBrowserPosition { +mut res := CMsgBrowserPosition{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_x = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.x = v +i = ii +} + +3 { +res.has_y = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.y = v +i = ii +} + +4 { +res.has_x_local = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.x_local = v +i = ii +} + +5 { +res.has_y_local = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.y_local = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgbrowserposition() CMsgBrowserPosition { +return CMsgBrowserPosition{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgbrowserposition(o CMsgBrowserPosition, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgbrowserposition(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgBrowserPosition) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgbrowserposition_unpack(v)? +return i, unpacked +} +pub struct CMsgBrowserResized { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +x int +has_x bool +y int +has_y bool +width u32 +has_width bool +height u32 +has_height bool +} +pub fn (o &CMsgBrowserResized) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_x { +res << vproto.pack_int32_field(o.x, 2) +} + +if o.has_y { +res << vproto.pack_int32_field(o.y, 3) +} + +if o.has_width { +res << vproto.pack_uint32_field(o.width, 4) +} + +if o.has_height { +res << vproto.pack_uint32_field(o.height, 5) +} + +return res +} + +pub fn cmsgbrowserresized_unpack(buf []byte) ?CMsgBrowserResized { +mut res := CMsgBrowserResized{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_x = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.x = v +i = ii +} + +3 { +res.has_y = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.y = v +i = ii +} + +4 { +res.has_width = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.width = v +i = ii +} + +5 { +res.has_height = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.height = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgbrowserresized() CMsgBrowserResized { +return CMsgBrowserResized{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgbrowserresized(o CMsgBrowserResized, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgbrowserresized(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgBrowserResized) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgbrowserresized_unpack(v)? +return i, unpacked +} +pub struct CMsgPostURl { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +url string +has_url bool +post string +has_post bool +pageserial u32 +has_pageserial bool +} +pub fn (o &CMsgPostURl) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_url { +res << vproto.pack_string_field(o.url, 2) +} + +if o.has_post { +res << vproto.pack_string_field(o.post, 3) +} + +if o.has_pageserial { +res << vproto.pack_uint32_field(o.pageserial, 4) +} + +return res +} + +pub fn cmsgposturl_unpack(buf []byte) ?CMsgPostURl { +mut res := CMsgPostURl{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url = v +i = ii +} + +3 { +res.has_post = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.post = v +i = ii +} + +4 { +res.has_pageserial = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.pageserial = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgposturl() CMsgPostURl { +return CMsgPostURl{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgposturl(o CMsgPostURl, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgposturl(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgPostURl) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgposturl_unpack(v)? +return i, unpacked +} +pub struct CMsgAddHeader { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +key string +has_key bool +value string +has_value bool +} +pub fn (o &CMsgAddHeader) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_key { +res << vproto.pack_string_field(o.key, 2) +} + +if o.has_value { +res << vproto.pack_string_field(o.value, 3) +} + +return res +} + +pub fn cmsgaddheader_unpack(buf []byte) ?CMsgAddHeader { +mut res := CMsgAddHeader{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_key = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.key = v +i = ii +} + +3 { +res.has_value = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.value = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgaddheader() CMsgAddHeader { +return CMsgAddHeader{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgaddheader(o CMsgAddHeader, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgaddheader(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgAddHeader) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgaddheader_unpack(v)? +return i, unpacked +} +pub struct CMsgStopLoad { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgStopLoad) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgstopload_unpack(buf []byte) ?CMsgStopLoad { +mut res := CMsgStopLoad{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgstopload() CMsgStopLoad { +return CMsgStopLoad{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgstopload(o CMsgStopLoad, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgstopload(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgStopLoad) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgstopload_unpack(v)? +return i, unpacked +} +pub struct CMsgReload { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgReload) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgreload_unpack(buf []byte) ?CMsgReload { +mut res := CMsgReload{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgreload() CMsgReload { +return CMsgReload{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgreload(o CMsgReload, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgreload(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgReload) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgreload_unpack(v)? +return i, unpacked +} +pub struct CMsgGoForward { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgGoForward) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsggoforward_unpack(buf []byte) ?CMsgGoForward { +mut res := CMsgGoForward{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggoforward() CMsgGoForward { +return CMsgGoForward{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggoforward(o CMsgGoForward, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggoforward(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGoForward) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggoforward_unpack(v)? +return i, unpacked +} +pub struct CMsgGoBack { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgGoBack) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsggoback_unpack(buf []byte) ?CMsgGoBack { +mut res := CMsgGoBack{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggoback() CMsgGoBack { +return CMsgGoBack{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggoback(o CMsgGoBack, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggoback(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGoBack) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggoback_unpack(v)? +return i, unpacked +} +pub struct CMsgWasHidden { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +hidden bool +has_hidden bool +} +pub fn (o &CMsgWasHidden) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_hidden { +res << vproto.pack_bool_field(o.hidden, 2) +} + +return res +} + +pub fn cmsgwashidden_unpack(buf []byte) ?CMsgWasHidden { +mut res := CMsgWasHidden{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_hidden = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.hidden = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgwashidden() CMsgWasHidden { +return CMsgWasHidden{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgwashidden(o CMsgWasHidden, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgwashidden(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgWasHidden) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgwashidden_unpack(v)? +return i, unpacked +} +pub struct CMsgClearHistory { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgClearHistory) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgclearhistory_unpack(buf []byte) ?CMsgClearHistory { +mut res := CMsgClearHistory{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclearhistory() CMsgClearHistory { +return CMsgClearHistory{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclearhistory(o CMsgClearHistory, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclearhistory(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClearHistory) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclearhistory_unpack(v)? +return i, unpacked +} +pub struct CMsgClearAllBrowsingData { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgClearAllBrowsingData) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgclearallbrowsingdata_unpack(buf []byte) ?CMsgClearAllBrowsingData { +mut res := CMsgClearAllBrowsingData{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclearallbrowsingdata() CMsgClearAllBrowsingData { +return CMsgClearAllBrowsingData{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclearallbrowsingdata(o CMsgClearAllBrowsingData, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclearallbrowsingdata(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClearAllBrowsingData) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclearallbrowsingdata_unpack(v)? +return i, unpacked +} +pub struct CMsgCopy { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgCopy) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgcopy_unpack(buf []byte) ?CMsgCopy { +mut res := CMsgCopy{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgcopy() CMsgCopy { +return CMsgCopy{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgcopy(o CMsgCopy, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgcopy(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgCopy) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgcopy_unpack(v)? +return i, unpacked +} +pub struct CMsgPaste { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgPaste) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgpaste_unpack(buf []byte) ?CMsgPaste { +mut res := CMsgPaste{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgpaste() CMsgPaste { +return CMsgPaste{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgpaste(o CMsgPaste, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgpaste(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgPaste) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgpaste_unpack(v)? +return i, unpacked +} +pub struct CMsgExecuteJavaScript { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +script string +has_script bool +} +pub fn (o &CMsgExecuteJavaScript) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_script { +res << vproto.pack_string_field(o.script, 2) +} + +return res +} + +pub fn cmsgexecutejavascript_unpack(buf []byte) ?CMsgExecuteJavaScript { +mut res := CMsgExecuteJavaScript{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_script = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.script = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgexecutejavascript() CMsgExecuteJavaScript { +return CMsgExecuteJavaScript{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgexecutejavascript(o CMsgExecuteJavaScript, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgexecutejavascript(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgExecuteJavaScript) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgexecutejavascript_unpack(v)? +return i, unpacked +} +pub struct CMsgSetFocus { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +focus bool +has_focus bool +} +pub fn (o &CMsgSetFocus) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_focus { +res << vproto.pack_bool_field(o.focus, 2) +} + +return res +} + +pub fn cmsgsetfocus_unpack(buf []byte) ?CMsgSetFocus { +mut res := CMsgSetFocus{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_focus = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.focus = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsetfocus() CMsgSetFocus { +return CMsgSetFocus{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsetfocus(o CMsgSetFocus, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsetfocus(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSetFocus) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsetfocus_unpack(v)? +return i, unpacked +} +pub struct CMsgHorizontalScrollBarSize { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgHorizontalScrollBarSize) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsghorizontalscrollbarsize_unpack(buf []byte) ?CMsgHorizontalScrollBarSize { +mut res := CMsgHorizontalScrollBarSize{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsghorizontalscrollbarsize() CMsgHorizontalScrollBarSize { +return CMsgHorizontalScrollBarSize{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsghorizontalscrollbarsize(o CMsgHorizontalScrollBarSize, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsghorizontalscrollbarsize(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgHorizontalScrollBarSize) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsghorizontalscrollbarsize_unpack(v)? +return i, unpacked +} +pub struct CMsgHorizontalScrollBarSizeResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +scroll_max u32 +has_scroll_max bool +scroll u32 +has_scroll bool +zoom f32 +has_zoom bool +visible bool +has_visible bool +page_size u32 +has_page_size bool +} +pub fn (o &CMsgHorizontalScrollBarSizeResponse) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_scroll_max { +res << vproto.pack_uint32_field(o.scroll_max, 6) +} + +if o.has_scroll { +res << vproto.pack_uint32_field(o.scroll, 7) +} + +if o.has_zoom { +res << vproto.pack_float_field(o.zoom, 8) +} + +if o.has_visible { +res << vproto.pack_bool_field(o.visible, 9) +} + +if o.has_page_size { +res << vproto.pack_uint32_field(o.page_size, 10) +} + +return res +} + +pub fn cmsghorizontalscrollbarsizeresponse_unpack(buf []byte) ?CMsgHorizontalScrollBarSizeResponse { +mut res := CMsgHorizontalScrollBarSizeResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +6 { +res.has_scroll_max = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.scroll_max = v +i = ii +} + +7 { +res.has_scroll = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.scroll = v +i = ii +} + +8 { +res.has_zoom = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.zoom = v +i = ii +} + +9 { +res.has_visible = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.visible = v +i = ii +} + +10 { +res.has_page_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.page_size = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsghorizontalscrollbarsizeresponse() CMsgHorizontalScrollBarSizeResponse { +return CMsgHorizontalScrollBarSizeResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsghorizontalscrollbarsizeresponse(o CMsgHorizontalScrollBarSizeResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsghorizontalscrollbarsizeresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgHorizontalScrollBarSizeResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsghorizontalscrollbarsizeresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgVerticalScrollBarSize { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgVerticalScrollBarSize) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgverticalscrollbarsize_unpack(buf []byte) ?CMsgVerticalScrollBarSize { +mut res := CMsgVerticalScrollBarSize{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgverticalscrollbarsize() CMsgVerticalScrollBarSize { +return CMsgVerticalScrollBarSize{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgverticalscrollbarsize(o CMsgVerticalScrollBarSize, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgverticalscrollbarsize(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgVerticalScrollBarSize) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgverticalscrollbarsize_unpack(v)? +return i, unpacked +} +pub struct CMsgVerticalScrollBarSizeResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +scroll_max u32 +has_scroll_max bool +scroll u32 +has_scroll bool +zoom f32 +has_zoom bool +visible bool +has_visible bool +page_size u32 +has_page_size bool +} +pub fn (o &CMsgVerticalScrollBarSizeResponse) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_scroll_max { +res << vproto.pack_uint32_field(o.scroll_max, 6) +} + +if o.has_scroll { +res << vproto.pack_uint32_field(o.scroll, 7) +} + +if o.has_zoom { +res << vproto.pack_float_field(o.zoom, 8) +} + +if o.has_visible { +res << vproto.pack_bool_field(o.visible, 9) +} + +if o.has_page_size { +res << vproto.pack_uint32_field(o.page_size, 10) +} + +return res +} + +pub fn cmsgverticalscrollbarsizeresponse_unpack(buf []byte) ?CMsgVerticalScrollBarSizeResponse { +mut res := CMsgVerticalScrollBarSizeResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +6 { +res.has_scroll_max = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.scroll_max = v +i = ii +} + +7 { +res.has_scroll = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.scroll = v +i = ii +} + +8 { +res.has_zoom = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.zoom = v +i = ii +} + +9 { +res.has_visible = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.visible = v +i = ii +} + +10 { +res.has_page_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.page_size = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgverticalscrollbarsizeresponse() CMsgVerticalScrollBarSizeResponse { +return CMsgVerticalScrollBarSizeResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgverticalscrollbarsizeresponse(o CMsgVerticalScrollBarSizeResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgverticalscrollbarsizeresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgVerticalScrollBarSizeResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgverticalscrollbarsizeresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgFind { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +find string +has_find bool +infind bool +has_infind bool +reverse bool +has_reverse bool +} +pub fn (o &CMsgFind) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_find { +res << vproto.pack_string_field(o.find, 2) +} + +if o.has_infind { +res << vproto.pack_bool_field(o.infind, 3) +} + +if o.has_reverse { +res << vproto.pack_bool_field(o.reverse, 4) +} + +return res +} + +pub fn cmsgfind_unpack(buf []byte) ?CMsgFind { +mut res := CMsgFind{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_find = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.find = v +i = ii +} + +3 { +res.has_infind = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.infind = v +i = ii +} + +4 { +res.has_reverse = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.reverse = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgfind() CMsgFind { +return CMsgFind{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgfind(o CMsgFind, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgfind(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgFind) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgfind_unpack(v)? +return i, unpacked +} +pub struct CMsgStopFind { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgStopFind) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgstopfind_unpack(buf []byte) ?CMsgStopFind { +mut res := CMsgStopFind{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgstopfind() CMsgStopFind { +return CMsgStopFind{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgstopfind(o CMsgStopFind, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgstopfind(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgStopFind) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgstopfind_unpack(v)? +return i, unpacked +} +pub struct CMsgSetHorizontalScroll { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +scroll u32 +has_scroll bool +} +pub fn (o &CMsgSetHorizontalScroll) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_scroll { +res << vproto.pack_uint32_field(o.scroll, 2) +} + +return res +} + +pub fn cmsgsethorizontalscroll_unpack(buf []byte) ?CMsgSetHorizontalScroll { +mut res := CMsgSetHorizontalScroll{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_scroll = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.scroll = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsethorizontalscroll() CMsgSetHorizontalScroll { +return CMsgSetHorizontalScroll{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsethorizontalscroll(o CMsgSetHorizontalScroll, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsethorizontalscroll(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSetHorizontalScroll) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsethorizontalscroll_unpack(v)? +return i, unpacked +} +pub struct CMsgSetVerticalScroll { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +scroll u32 +has_scroll bool +} +pub fn (o &CMsgSetVerticalScroll) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_scroll { +res << vproto.pack_uint32_field(o.scroll, 2) +} + +return res +} + +pub fn cmsgsetverticalscroll_unpack(buf []byte) ?CMsgSetVerticalScroll { +mut res := CMsgSetVerticalScroll{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_scroll = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.scroll = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsetverticalscroll() CMsgSetVerticalScroll { +return CMsgSetVerticalScroll{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsetverticalscroll(o CMsgSetVerticalScroll, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsetverticalscroll(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSetVerticalScroll) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsetverticalscroll_unpack(v)? +return i, unpacked +} +pub struct CMsgSetZoomLevel { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +zoom f64 +has_zoom bool +} +pub fn (o &CMsgSetZoomLevel) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_zoom { +res << vproto.pack_double_field(o.zoom, 2) +} + +return res +} + +pub fn cmsgsetzoomlevel_unpack(buf []byte) ?CMsgSetZoomLevel { +mut res := CMsgSetZoomLevel{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_zoom = true +ii, v := vproto.unpack_double_field(cur_buf, tag_wiretype.wire_type)? +res.zoom = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsetzoomlevel() CMsgSetZoomLevel { +return CMsgSetZoomLevel{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsetzoomlevel(o CMsgSetZoomLevel, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsetzoomlevel(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSetZoomLevel) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsetzoomlevel_unpack(v)? +return i, unpacked +} +pub struct CMsgViewSource { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgViewSource) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgviewsource_unpack(buf []byte) ?CMsgViewSource { +mut res := CMsgViewSource{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgviewsource() CMsgViewSource { +return CMsgViewSource{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgviewsource(o CMsgViewSource, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgviewsource(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgViewSource) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgviewsource_unpack(v)? +return i, unpacked +} +pub struct CMsgBrowserReady { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +vr_overlay_key string +has_vr_overlay_key bool +hwnd_browser u64 +has_hwnd_browser bool +} +pub fn (o &CMsgBrowserReady) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_vr_overlay_key { +res << vproto.pack_string_field(o.vr_overlay_key, 2) +} + +if o.has_hwnd_browser { +res << vproto.pack_64bit_field(o.hwnd_browser, 3) +} + +return res +} + +pub fn cmsgbrowserready_unpack(buf []byte) ?CMsgBrowserReady { +mut res := CMsgBrowserReady{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_vr_overlay_key = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.vr_overlay_key = v +i = ii +} + +3 { +res.has_hwnd_browser = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.hwnd_browser = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgbrowserready() CMsgBrowserReady { +return CMsgBrowserReady{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgbrowserready(o CMsgBrowserReady, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgbrowserready(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgBrowserReady) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgbrowserready_unpack(v)? +return i, unpacked +} +pub struct CMsgURlchanged { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +url string +has_url bool +postdata string +has_postdata bool +bisredirect bool +has_bisredirect bool +pagetitle string +has_pagetitle bool +bnewnavigation bool +has_bnewnavigation bool +} +pub fn (o &CMsgURlchanged) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_url { +res << vproto.pack_string_field(o.url, 2) +} + +if o.has_postdata { +res << vproto.pack_string_field(o.postdata, 3) +} + +if o.has_bisredirect { +res << vproto.pack_bool_field(o.bisredirect, 4) +} + +if o.has_pagetitle { +res << vproto.pack_string_field(o.pagetitle, 5) +} + +if o.has_bnewnavigation { +res << vproto.pack_bool_field(o.bnewnavigation, 6) +} + +return res +} + +pub fn cmsgurlchanged_unpack(buf []byte) ?CMsgURlchanged { +mut res := CMsgURlchanged{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url = v +i = ii +} + +3 { +res.has_postdata = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.postdata = v +i = ii +} + +4 { +res.has_bisredirect = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.bisredirect = v +i = ii +} + +5 { +res.has_pagetitle = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.pagetitle = v +i = ii +} + +6 { +res.has_bnewnavigation = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.bnewnavigation = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgurlchanged() CMsgURlchanged { +return CMsgURlchanged{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgurlchanged(o CMsgURlchanged, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgurlchanged(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgURlchanged) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgurlchanged_unpack(v)? +return i, unpacked +} +pub struct CHtmlheader { +mut: +unknown_fields []vproto.UnknownField +pub mut: +key string +has_key bool +value string +has_value bool +} +pub fn (o &CHtmlheader) pack() []byte { +mut res := []byte{} +if o.has_key { +res << vproto.pack_string_field(o.key, 1) +} + +if o.has_value { +res << vproto.pack_string_field(o.value, 2) +} + +return res +} + +pub fn chtmlheader_unpack(buf []byte) ?CHtmlheader { +mut res := CHtmlheader{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_key = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.key = v +i = ii +} + +2 { +res.has_value = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.value = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_chtmlheader() CHtmlheader { +return CHtmlheader{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_chtmlheader(o CHtmlheader, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_chtmlheader(buf []byte, tag_wiretype vproto.WireType) ?(int, CHtmlheader) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := chtmlheader_unpack(v)? +return i, unpacked +} +pub struct CHtmlpageSecurityInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +bissecure bool +has_bissecure bool +bhascerterror bool +has_bhascerterror bool +issuername string +has_issuername bool +certname string +has_certname bool +certexpiry int +has_certexpiry bool +ncertbits int +has_ncertbits bool +bisevcert bool +has_bisevcert bool +} +pub fn (o &CHtmlpageSecurityInfo) pack() []byte { +mut res := []byte{} +if o.has_bissecure { +res << vproto.pack_bool_field(o.bissecure, 1) +} + +if o.has_bhascerterror { +res << vproto.pack_bool_field(o.bhascerterror, 2) +} + +if o.has_issuername { +res << vproto.pack_string_field(o.issuername, 3) +} + +if o.has_certname { +res << vproto.pack_string_field(o.certname, 4) +} + +if o.has_certexpiry { +res << vproto.pack_int32_field(o.certexpiry, 5) +} + +if o.has_ncertbits { +res << vproto.pack_int32_field(o.ncertbits, 6) +} + +if o.has_bisevcert { +res << vproto.pack_bool_field(o.bisevcert, 7) +} + +return res +} + +pub fn chtmlpagesecurityinfo_unpack(buf []byte) ?CHtmlpageSecurityInfo { +mut res := CHtmlpageSecurityInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_bissecure = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.bissecure = v +i = ii +} + +2 { +res.has_bhascerterror = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.bhascerterror = v +i = ii +} + +3 { +res.has_issuername = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.issuername = v +i = ii +} + +4 { +res.has_certname = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.certname = v +i = ii +} + +5 { +res.has_certexpiry = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.certexpiry = v +i = ii +} + +6 { +res.has_ncertbits = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.ncertbits = v +i = ii +} + +7 { +res.has_bisevcert = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.bisevcert = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_chtmlpagesecurityinfo() CHtmlpageSecurityInfo { +return CHtmlpageSecurityInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_chtmlpagesecurityinfo(o CHtmlpageSecurityInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_chtmlpagesecurityinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CHtmlpageSecurityInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := chtmlpagesecurityinfo_unpack(v)? +return i, unpacked +} +pub struct CMsgFinishedRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +url string +has_url bool +pagetitle string +has_pagetitle bool +} +pub fn (o &CMsgFinishedRequest) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_url { +res << vproto.pack_string_field(o.url, 2) +} + +if o.has_pagetitle { +res << vproto.pack_string_field(o.pagetitle, 3) +} + +return res +} + +pub fn cmsgfinishedrequest_unpack(buf []byte) ?CMsgFinishedRequest { +mut res := CMsgFinishedRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url = v +i = ii +} + +3 { +res.has_pagetitle = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.pagetitle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgfinishedrequest() CMsgFinishedRequest { +return CMsgFinishedRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgfinishedrequest(o CMsgFinishedRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgfinishedrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgFinishedRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgfinishedrequest_unpack(v)? +return i, unpacked +} +pub struct CMsgLoadedRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +url string +has_url bool +pagetitle string +has_pagetitle bool +headers []CHtmlheader +} +pub fn (o &CMsgLoadedRequest) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_url { +res << vproto.pack_string_field(o.url, 2) +} + +if o.has_pagetitle { +res << vproto.pack_string_field(o.pagetitle, 3) +} + +// [packed=false] +for _, x in o.headers { +res << zzz_vproto_internal_pack_chtmlheader(x, 5) +} + +return res +} + +pub fn cmsgloadedrequest_unpack(buf []byte) ?CMsgLoadedRequest { +mut res := CMsgLoadedRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url = v +i = ii +} + +3 { +res.has_pagetitle = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.pagetitle = v +i = ii +} + +5 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_chtmlheader(cur_buf, tag_wiretype.wire_type)? +res.headers << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgloadedrequest() CMsgLoadedRequest { +return CMsgLoadedRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgloadedrequest(o CMsgLoadedRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgloadedrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgLoadedRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgloadedrequest_unpack(v)? +return i, unpacked +} +pub struct CMsgPageSecurity { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +url string +has_url bool +security_info CHtmlpageSecurityInfo +has_security_info bool +} +pub fn (o &CMsgPageSecurity) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_url { +res << vproto.pack_string_field(o.url, 2) +} + +if o.has_security_info { +res << zzz_vproto_internal_pack_chtmlpagesecurityinfo(o.security_info, 3) +} + +return res +} + +pub fn cmsgpagesecurity_unpack(buf []byte) ?CMsgPageSecurity { +mut res := CMsgPageSecurity{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url = v +i = ii +} + +3 { +res.has_security_info = true +ii, v := zzz_vproto_internal_unpack_chtmlpagesecurityinfo(cur_buf, tag_wiretype.wire_type)? +res.security_info = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgpagesecurity() CMsgPageSecurity { +return CMsgPageSecurity{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgpagesecurity(o CMsgPageSecurity, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgpagesecurity(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgPageSecurity) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgpagesecurity_unpack(v)? +return i, unpacked +} +pub struct CMsgStartRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +url string +has_url bool +target string +has_target bool +postdata string +has_postdata bool +bisredirect bool +has_bisredirect bool +} +pub fn (o &CMsgStartRequest) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_url { +res << vproto.pack_string_field(o.url, 2) +} + +if o.has_target { +res << vproto.pack_string_field(o.target, 3) +} + +if o.has_postdata { +res << vproto.pack_string_field(o.postdata, 4) +} + +if o.has_bisredirect { +res << vproto.pack_bool_field(o.bisredirect, 5) +} + +return res +} + +pub fn cmsgstartrequest_unpack(buf []byte) ?CMsgStartRequest { +mut res := CMsgStartRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url = v +i = ii +} + +3 { +res.has_target = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.target = v +i = ii +} + +4 { +res.has_postdata = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.postdata = v +i = ii +} + +5 { +res.has_bisredirect = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.bisredirect = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgstartrequest() CMsgStartRequest { +return CMsgStartRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgstartrequest(o CMsgStartRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgstartrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgStartRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgstartrequest_unpack(v)? +return i, unpacked +} +pub struct CMsgStartRequestResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +ballow bool +has_ballow bool +} +pub fn (o &CMsgStartRequestResponse) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_ballow { +res << vproto.pack_bool_field(o.ballow, 2) +} + +return res +} + +pub fn cmsgstartrequestresponse_unpack(buf []byte) ?CMsgStartRequestResponse { +mut res := CMsgStartRequestResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_ballow = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.ballow = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgstartrequestresponse() CMsgStartRequestResponse { +return CMsgStartRequestResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgstartrequestresponse(o CMsgStartRequestResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgstartrequestresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgStartRequestResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgstartrequestresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgShowPopup { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgShowPopup) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgshowpopup_unpack(buf []byte) ?CMsgShowPopup { +mut res := CMsgShowPopup{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgshowpopup() CMsgShowPopup { +return CMsgShowPopup{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgshowpopup(o CMsgShowPopup, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgshowpopup(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgShowPopup) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgshowpopup_unpack(v)? +return i, unpacked +} +pub struct CMsgHidePopup { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgHidePopup) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsghidepopup_unpack(buf []byte) ?CMsgHidePopup { +mut res := CMsgHidePopup{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsghidepopup() CMsgHidePopup { +return CMsgHidePopup{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsghidepopup(o CMsgHidePopup, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsghidepopup(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgHidePopup) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsghidepopup_unpack(v)? +return i, unpacked +} +pub struct CMsgSizePopup { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +x int +has_x bool +y int +has_y bool +wide u32 +has_wide bool +tall u32 +has_tall bool +} +pub fn (o &CMsgSizePopup) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_x { +res << vproto.pack_int32_field(o.x, 2) +} + +if o.has_y { +res << vproto.pack_int32_field(o.y, 3) +} + +if o.has_wide { +res << vproto.pack_uint32_field(o.wide, 4) +} + +if o.has_tall { +res << vproto.pack_uint32_field(o.tall, 5) +} + +return res +} + +pub fn cmsgsizepopup_unpack(buf []byte) ?CMsgSizePopup { +mut res := CMsgSizePopup{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_x = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.x = v +i = ii +} + +3 { +res.has_y = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.y = v +i = ii +} + +4 { +res.has_wide = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.wide = v +i = ii +} + +5 { +res.has_tall = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.tall = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsizepopup() CMsgSizePopup { +return CMsgSizePopup{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsizepopup(o CMsgSizePopup, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsizepopup(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSizePopup) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsizepopup_unpack(v)? +return i, unpacked +} +pub struct CMsgOpenNewTab { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +url string +has_url bool +bforeground bool +has_bforeground bool +} +pub fn (o &CMsgOpenNewTab) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_url { +res << vproto.pack_string_field(o.url, 2) +} + +if o.has_bforeground { +res << vproto.pack_bool_field(o.bforeground, 3) +} + +return res +} + +pub fn cmsgopennewtab_unpack(buf []byte) ?CMsgOpenNewTab { +mut res := CMsgOpenNewTab{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url = v +i = ii +} + +3 { +res.has_bforeground = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.bforeground = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgopennewtab() CMsgOpenNewTab { +return CMsgOpenNewTab{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgopennewtab(o CMsgOpenNewTab, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgopennewtab(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgOpenNewTab) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgopennewtab_unpack(v)? +return i, unpacked +} +pub struct CMsgPopupHTmlwindow { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +url string +has_url bool +x int +has_x bool +y int +has_y bool +wide u32 +has_wide bool +tall u32 +has_tall bool +popup_index u32 +has_popup_index bool +trusted_creator bool +has_trusted_creator bool +} +pub fn (o &CMsgPopupHTmlwindow) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_url { +res << vproto.pack_string_field(o.url, 2) +} + +if o.has_x { +res << vproto.pack_int32_field(o.x, 3) +} + +if o.has_y { +res << vproto.pack_int32_field(o.y, 4) +} + +if o.has_wide { +res << vproto.pack_uint32_field(o.wide, 5) +} + +if o.has_tall { +res << vproto.pack_uint32_field(o.tall, 6) +} + +if o.has_popup_index { +res << vproto.pack_uint32_field(o.popup_index, 7) +} + +if o.has_trusted_creator { +res << vproto.pack_bool_field(o.trusted_creator, 8) +} + +return res +} + +pub fn cmsgpopuphtmlwindow_unpack(buf []byte) ?CMsgPopupHTmlwindow { +mut res := CMsgPopupHTmlwindow{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url = v +i = ii +} + +3 { +res.has_x = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.x = v +i = ii +} + +4 { +res.has_y = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.y = v +i = ii +} + +5 { +res.has_wide = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.wide = v +i = ii +} + +6 { +res.has_tall = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.tall = v +i = ii +} + +7 { +res.has_popup_index = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.popup_index = v +i = ii +} + +8 { +res.has_trusted_creator = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.trusted_creator = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgpopuphtmlwindow() CMsgPopupHTmlwindow { +return CMsgPopupHTmlwindow{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgpopuphtmlwindow(o CMsgPopupHTmlwindow, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgpopuphtmlwindow(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgPopupHTmlwindow) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgpopuphtmlwindow_unpack(v)? +return i, unpacked +} +pub struct CMsgPopupHTmlwindowResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +ballow bool +has_ballow bool +} +pub fn (o &CMsgPopupHTmlwindowResponse) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_ballow { +res << vproto.pack_bool_field(o.ballow, 2) +} + +return res +} + +pub fn cmsgpopuphtmlwindowresponse_unpack(buf []byte) ?CMsgPopupHTmlwindowResponse { +mut res := CMsgPopupHTmlwindowResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_ballow = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.ballow = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgpopuphtmlwindowresponse() CMsgPopupHTmlwindowResponse { +return CMsgPopupHTmlwindowResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgpopuphtmlwindowresponse(o CMsgPopupHTmlwindowResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgpopuphtmlwindowresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgPopupHTmlwindowResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgpopuphtmlwindowresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgSetHTmltitle { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +title string +has_title bool +} +pub fn (o &CMsgSetHTmltitle) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_title { +res << vproto.pack_string_field(o.title, 2) +} + +return res +} + +pub fn cmsgsethtmltitle_unpack(buf []byte) ?CMsgSetHTmltitle { +mut res := CMsgSetHTmltitle{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_title = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.title = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsethtmltitle() CMsgSetHTmltitle { +return CMsgSetHTmltitle{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsethtmltitle(o CMsgSetHTmltitle, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsethtmltitle(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSetHTmltitle) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsethtmltitle_unpack(v)? +return i, unpacked +} +pub struct CMsgLoadingResource { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +url string +has_url bool +} +pub fn (o &CMsgLoadingResource) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_url { +res << vproto.pack_string_field(o.url, 2) +} + +return res +} + +pub fn cmsgloadingresource_unpack(buf []byte) ?CMsgLoadingResource { +mut res := CMsgLoadingResource{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgloadingresource() CMsgLoadingResource { +return CMsgLoadingResource{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgloadingresource(o CMsgLoadingResource, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgloadingresource(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgLoadingResource) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgloadingresource_unpack(v)? +return i, unpacked +} +pub struct CMsgStatusText { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +text string +has_text bool +} +pub fn (o &CMsgStatusText) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_text { +res << vproto.pack_string_field(o.text, 2) +} + +return res +} + +pub fn cmsgstatustext_unpack(buf []byte) ?CMsgStatusText { +mut res := CMsgStatusText{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_text = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.text = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgstatustext() CMsgStatusText { +return CMsgStatusText{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgstatustext(o CMsgStatusText, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgstatustext(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgStatusText) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgstatustext_unpack(v)? +return i, unpacked +} +pub struct CMsgSetCursor { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +cursor u32 +has_cursor bool +custom_data []byte +has_custom_data bool +wide u32 +has_wide bool +tall u32 +has_tall bool +xhotspot u32 +has_xhotspot bool +yhotspot u32 +has_yhotspot bool +} +pub fn (o &CMsgSetCursor) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_cursor { +res << vproto.pack_uint32_field(o.cursor, 2) +} + +if o.has_custom_data { +res << vproto.pack_bytes_field(o.custom_data, 3) +} + +if o.has_wide { +res << vproto.pack_uint32_field(o.wide, 4) +} + +if o.has_tall { +res << vproto.pack_uint32_field(o.tall, 5) +} + +if o.has_xhotspot { +res << vproto.pack_uint32_field(o.xhotspot, 6) +} + +if o.has_yhotspot { +res << vproto.pack_uint32_field(o.yhotspot, 7) +} + +return res +} + +pub fn cmsgsetcursor_unpack(buf []byte) ?CMsgSetCursor { +mut res := CMsgSetCursor{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_cursor = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cursor = v +i = ii +} + +3 { +res.has_custom_data = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.custom_data = v +i = ii +} + +4 { +res.has_wide = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.wide = v +i = ii +} + +5 { +res.has_tall = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.tall = v +i = ii +} + +6 { +res.has_xhotspot = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.xhotspot = v +i = ii +} + +7 { +res.has_yhotspot = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.yhotspot = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsetcursor() CMsgSetCursor { +return CMsgSetCursor{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsetcursor(o CMsgSetCursor, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsetcursor(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSetCursor) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsetcursor_unpack(v)? +return i, unpacked +} +pub struct CMsgFileLoadDialog { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +title string +has_title bool +initialfile string +has_initialfile bool +accept_types []string +is_save bool +has_is_save bool +} +pub fn (o &CMsgFileLoadDialog) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_title { +res << vproto.pack_string_field(o.title, 2) +} + +if o.has_initialfile { +res << vproto.pack_string_field(o.initialfile, 3) +} + +// [packed=false] +for _, x in o.accept_types { +res << vproto.pack_string_field(x, 4) +} + +if o.has_is_save { +res << vproto.pack_bool_field(o.is_save, 5) +} + +return res +} + +pub fn cmsgfileloaddialog_unpack(buf []byte) ?CMsgFileLoadDialog { +mut res := CMsgFileLoadDialog{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_title = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.title = v +i = ii +} + +3 { +res.has_initialfile = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.initialfile = v +i = ii +} + +4 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.accept_types << v +i = ii +} + +5 { +res.has_is_save = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_save = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgfileloaddialog() CMsgFileLoadDialog { +return CMsgFileLoadDialog{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgfileloaddialog(o CMsgFileLoadDialog, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgfileloaddialog(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgFileLoadDialog) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgfileloaddialog_unpack(v)? +return i, unpacked +} +pub struct CMsgFileLoadDialogResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +files []string +} +pub fn (o &CMsgFileLoadDialogResponse) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +// [packed=false] +for _, x in o.files { +res << vproto.pack_string_field(x, 2) +} + +return res +} + +pub fn cmsgfileloaddialogresponse_unpack(buf []byte) ?CMsgFileLoadDialogResponse { +mut res := CMsgFileLoadDialogResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.files << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgfileloaddialogresponse() CMsgFileLoadDialogResponse { +return CMsgFileLoadDialogResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgfileloaddialogresponse(o CMsgFileLoadDialogResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgfileloaddialogresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgFileLoadDialogResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgfileloaddialogresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgShowToolTip { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +text string +has_text bool +} +pub fn (o &CMsgShowToolTip) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_text { +res << vproto.pack_string_field(o.text, 2) +} + +return res +} + +pub fn cmsgshowtooltip_unpack(buf []byte) ?CMsgShowToolTip { +mut res := CMsgShowToolTip{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_text = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.text = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgshowtooltip() CMsgShowToolTip { +return CMsgShowToolTip{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgshowtooltip(o CMsgShowToolTip, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgshowtooltip(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgShowToolTip) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgshowtooltip_unpack(v)? +return i, unpacked +} +pub struct CMsgUpdateToolTip { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +text string +has_text bool +} +pub fn (o &CMsgUpdateToolTip) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_text { +res << vproto.pack_string_field(o.text, 2) +} + +return res +} + +pub fn cmsgupdatetooltip_unpack(buf []byte) ?CMsgUpdateToolTip { +mut res := CMsgUpdateToolTip{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_text = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.text = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgupdatetooltip() CMsgUpdateToolTip { +return CMsgUpdateToolTip{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgupdatetooltip(o CMsgUpdateToolTip, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgupdatetooltip(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgUpdateToolTip) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgupdatetooltip_unpack(v)? +return i, unpacked +} +pub struct CMsgHideToolTip { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgHideToolTip) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsghidetooltip_unpack(buf []byte) ?CMsgHideToolTip { +mut res := CMsgHideToolTip{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsghidetooltip() CMsgHideToolTip { +return CMsgHideToolTip{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsghidetooltip(o CMsgHideToolTip, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsghidetooltip(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgHideToolTip) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsghidetooltip_unpack(v)? +return i, unpacked +} +pub struct CMsgSearchResults { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +activematch int +has_activematch bool +results int +has_results bool +} +pub fn (o &CMsgSearchResults) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_activematch { +res << vproto.pack_int32_field(o.activematch, 2) +} + +if o.has_results { +res << vproto.pack_int32_field(o.results, 3) +} + +return res +} + +pub fn cmsgsearchresults_unpack(buf []byte) ?CMsgSearchResults { +mut res := CMsgSearchResults{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_activematch = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.activematch = v +i = ii +} + +3 { +res.has_results = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.results = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsearchresults() CMsgSearchResults { +return CMsgSearchResults{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsearchresults(o CMsgSearchResults, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsearchresults(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSearchResults) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsearchresults_unpack(v)? +return i, unpacked +} +pub struct CMsgClose { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgClose) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgclose_unpack(buf []byte) ?CMsgClose { +mut res := CMsgClose{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclose() CMsgClose { +return CMsgClose{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclose(o CMsgClose, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclose(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClose) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclose_unpack(v)? +return i, unpacked +} +pub struct CMsgSetSharedPaintBuffers { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +wide u32 +has_wide bool +tall u32 +has_tall bool +source_pid u64 +has_source_pid bool +source_handle u64 +has_source_handle bool +handle u64 +has_handle bool +} +pub fn (o &CMsgSetSharedPaintBuffers) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_wide { +res << vproto.pack_uint32_field(o.wide, 2) +} + +if o.has_tall { +res << vproto.pack_uint32_field(o.tall, 3) +} + +if o.has_source_pid { +res << vproto.pack_uint64_field(o.source_pid, 4) +} + +if o.has_source_handle { +res << vproto.pack_uint64_field(o.source_handle, 5) +} + +if o.has_handle { +res << vproto.pack_uint64_field(o.handle, 6) +} + +return res +} + +pub fn cmsgsetsharedpaintbuffers_unpack(buf []byte) ?CMsgSetSharedPaintBuffers { +mut res := CMsgSetSharedPaintBuffers{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_wide = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.wide = v +i = ii +} + +3 { +res.has_tall = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.tall = v +i = ii +} + +4 { +res.has_source_pid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.source_pid = v +i = ii +} + +5 { +res.has_source_handle = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.source_handle = v +i = ii +} + +6 { +res.has_handle = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsetsharedpaintbuffers() CMsgSetSharedPaintBuffers { +return CMsgSetSharedPaintBuffers{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsetsharedpaintbuffers(o CMsgSetSharedPaintBuffers, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsetsharedpaintbuffers(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSetSharedPaintBuffers) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsetsharedpaintbuffers_unpack(v)? +return i, unpacked +} +pub struct CMsgAckSharedPaintBuffers { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgAckSharedPaintBuffers) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgacksharedpaintbuffers_unpack(buf []byte) ?CMsgAckSharedPaintBuffers { +mut res := CMsgAckSharedPaintBuffers{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgacksharedpaintbuffers() CMsgAckSharedPaintBuffers { +return CMsgAckSharedPaintBuffers{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgacksharedpaintbuffers(o CMsgAckSharedPaintBuffers, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgacksharedpaintbuffers(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgAckSharedPaintBuffers) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgacksharedpaintbuffers_unpack(v)? +return i, unpacked +} +pub struct CMsgNeedsPaint { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +scrollx u32 +has_scrollx bool +scrolly u32 +has_scrolly bool +pagescale f32 +has_pagescale bool +pageserial u32 +has_pageserial bool +} +pub fn (o &CMsgNeedsPaint) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_scrollx { +res << vproto.pack_uint32_field(o.scrollx, 10) +} + +if o.has_scrolly { +res << vproto.pack_uint32_field(o.scrolly, 11) +} + +if o.has_pagescale { +res << vproto.pack_float_field(o.pagescale, 12) +} + +if o.has_pageserial { +res << vproto.pack_uint32_field(o.pageserial, 15) +} + +return res +} + +pub fn cmsgneedspaint_unpack(buf []byte) ?CMsgNeedsPaint { +mut res := CMsgNeedsPaint{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +10 { +res.has_scrollx = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.scrollx = v +i = ii +} + +11 { +res.has_scrolly = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.scrolly = v +i = ii +} + +12 { +res.has_pagescale = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.pagescale = v +i = ii +} + +15 { +res.has_pageserial = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.pageserial = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgneedspaint() CMsgNeedsPaint { +return CMsgNeedsPaint{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgneedspaint(o CMsgNeedsPaint, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgneedspaint(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgNeedsPaint) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgneedspaint_unpack(v)? +return i, unpacked +} +pub struct CMsgComboNeedsPaint { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +rgba u64 +has_rgba bool +combobox_wide u32 +has_combobox_wide bool +combobox_tall u32 +has_combobox_tall bool +shared_memory_handle u64 +has_shared_memory_handle bool +shared_memory_size u64 +has_shared_memory_size bool +} +pub fn (o &CMsgComboNeedsPaint) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_rgba { +res << vproto.pack_uint64_field(o.rgba, 2) +} + +if o.has_combobox_wide { +res << vproto.pack_uint32_field(o.combobox_wide, 3) +} + +if o.has_combobox_tall { +res << vproto.pack_uint32_field(o.combobox_tall, 4) +} + +if o.has_shared_memory_handle { +res << vproto.pack_uint64_field(o.shared_memory_handle, 5) +} + +if o.has_shared_memory_size { +res << vproto.pack_uint64_field(o.shared_memory_size, 7) +} + +return res +} + +pub fn cmsgcomboneedspaint_unpack(buf []byte) ?CMsgComboNeedsPaint { +mut res := CMsgComboNeedsPaint{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_rgba = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.rgba = v +i = ii +} + +3 { +res.has_combobox_wide = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.combobox_wide = v +i = ii +} + +4 { +res.has_combobox_tall = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.combobox_tall = v +i = ii +} + +5 { +res.has_shared_memory_handle = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.shared_memory_handle = v +i = ii +} + +7 { +res.has_shared_memory_size = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.shared_memory_size = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgcomboneedspaint() CMsgComboNeedsPaint { +return CMsgComboNeedsPaint{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgcomboneedspaint(o CMsgComboNeedsPaint, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgcomboneedspaint(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgComboNeedsPaint) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgcomboneedspaint_unpack(v)? +return i, unpacked +} +pub struct CMsgNeedsSharedTexturePaint { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +share_handle u32 +has_share_handle bool +width u32 +has_width bool +height u32 +has_height bool +scrollx u32 +has_scrollx bool +scrolly u32 +has_scrolly bool +pagescale f32 +has_pagescale bool +pageserial u32 +has_pageserial bool +} +pub fn (o &CMsgNeedsSharedTexturePaint) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_share_handle { +res << vproto.pack_uint32_field(o.share_handle, 2) +} + +if o.has_width { +res << vproto.pack_uint32_field(o.width, 3) +} + +if o.has_height { +res << vproto.pack_uint32_field(o.height, 4) +} + +if o.has_scrollx { +res << vproto.pack_uint32_field(o.scrollx, 5) +} + +if o.has_scrolly { +res << vproto.pack_uint32_field(o.scrolly, 6) +} + +if o.has_pagescale { +res << vproto.pack_float_field(o.pagescale, 7) +} + +if o.has_pageserial { +res << vproto.pack_uint32_field(o.pageserial, 8) +} + +return res +} + +pub fn cmsgneedssharedtexturepaint_unpack(buf []byte) ?CMsgNeedsSharedTexturePaint { +mut res := CMsgNeedsSharedTexturePaint{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_share_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.share_handle = v +i = ii +} + +3 { +res.has_width = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.width = v +i = ii +} + +4 { +res.has_height = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.height = v +i = ii +} + +5 { +res.has_scrollx = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.scrollx = v +i = ii +} + +6 { +res.has_scrolly = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.scrolly = v +i = ii +} + +7 { +res.has_pagescale = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.pagescale = v +i = ii +} + +8 { +res.has_pageserial = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.pageserial = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgneedssharedtexturepaint() CMsgNeedsSharedTexturePaint { +return CMsgNeedsSharedTexturePaint{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgneedssharedtexturepaint(o CMsgNeedsSharedTexturePaint, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgneedssharedtexturepaint(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgNeedsSharedTexturePaint) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgneedssharedtexturepaint_unpack(v)? +return i, unpacked +} +pub struct CMsgGameOverlayTexturePaint { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +width u32 +has_width bool +height u32 +has_height bool +scrollx u32 +has_scrollx bool +scrolly u32 +has_scrolly bool +pagescale f32 +has_pagescale bool +pageserial u32 +has_pageserial bool +} +pub fn (o &CMsgGameOverlayTexturePaint) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_width { +res << vproto.pack_uint32_field(o.width, 3) +} + +if o.has_height { +res << vproto.pack_uint32_field(o.height, 4) +} + +if o.has_scrollx { +res << vproto.pack_uint32_field(o.scrollx, 5) +} + +if o.has_scrolly { +res << vproto.pack_uint32_field(o.scrolly, 6) +} + +if o.has_pagescale { +res << vproto.pack_float_field(o.pagescale, 7) +} + +if o.has_pageserial { +res << vproto.pack_uint32_field(o.pageserial, 8) +} + +return res +} + +pub fn cmsggameoverlaytexturepaint_unpack(buf []byte) ?CMsgGameOverlayTexturePaint { +mut res := CMsgGameOverlayTexturePaint{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +3 { +res.has_width = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.width = v +i = ii +} + +4 { +res.has_height = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.height = v +i = ii +} + +5 { +res.has_scrollx = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.scrollx = v +i = ii +} + +6 { +res.has_scrolly = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.scrolly = v +i = ii +} + +7 { +res.has_pagescale = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.pagescale = v +i = ii +} + +8 { +res.has_pageserial = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.pageserial = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggameoverlaytexturepaint() CMsgGameOverlayTexturePaint { +return CMsgGameOverlayTexturePaint{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggameoverlaytexturepaint(o CMsgGameOverlayTexturePaint, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggameoverlaytexturepaint(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGameOverlayTexturePaint) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggameoverlaytexturepaint_unpack(v)? +return i, unpacked +} +pub struct CMsgGetZoom { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgGetZoom) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsggetzoom_unpack(buf []byte) ?CMsgGetZoom { +mut res := CMsgGetZoom{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggetzoom() CMsgGetZoom { +return CMsgGetZoom{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggetzoom(o CMsgGetZoom, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggetzoom(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGetZoom) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggetzoom_unpack(v)? +return i, unpacked +} +pub struct CMsgGetZoomResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +zoom f32 +has_zoom bool +} +pub fn (o &CMsgGetZoomResponse) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_zoom { +res << vproto.pack_float_field(o.zoom, 2) +} + +return res +} + +pub fn cmsggetzoomresponse_unpack(buf []byte) ?CMsgGetZoomResponse { +mut res := CMsgGetZoomResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_zoom = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.zoom = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggetzoomresponse() CMsgGetZoomResponse { +return CMsgGetZoomResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggetzoomresponse(o CMsgGetZoomResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggetzoomresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGetZoomResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggetzoomresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgLinkAtPosition { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +x u32 +has_x bool +y u32 +has_y bool +} +pub fn (o &CMsgLinkAtPosition) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_x { +res << vproto.pack_uint32_field(o.x, 2) +} + +if o.has_y { +res << vproto.pack_uint32_field(o.y, 3) +} + +return res +} + +pub fn cmsglinkatposition_unpack(buf []byte) ?CMsgLinkAtPosition { +mut res := CMsgLinkAtPosition{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_x = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.x = v +i = ii +} + +3 { +res.has_y = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.y = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsglinkatposition() CMsgLinkAtPosition { +return CMsgLinkAtPosition{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsglinkatposition(o CMsgLinkAtPosition, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsglinkatposition(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgLinkAtPosition) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsglinkatposition_unpack(v)? +return i, unpacked +} +pub struct CMsgLinkAtPositionResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +x u32 +has_x bool +y u32 +has_y bool +url string +has_url bool +blivelink bool +has_blivelink bool +binput bool +has_binput bool +} +pub fn (o &CMsgLinkAtPositionResponse) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_x { +res << vproto.pack_uint32_field(o.x, 2) +} + +if o.has_y { +res << vproto.pack_uint32_field(o.y, 3) +} + +if o.has_url { +res << vproto.pack_string_field(o.url, 4) +} + +if o.has_blivelink { +res << vproto.pack_bool_field(o.blivelink, 5) +} + +if o.has_binput { +res << vproto.pack_bool_field(o.binput, 6) +} + +return res +} + +pub fn cmsglinkatpositionresponse_unpack(buf []byte) ?CMsgLinkAtPositionResponse { +mut res := CMsgLinkAtPositionResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_x = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.x = v +i = ii +} + +3 { +res.has_y = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.y = v +i = ii +} + +4 { +res.has_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url = v +i = ii +} + +5 { +res.has_blivelink = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.blivelink = v +i = ii +} + +6 { +res.has_binput = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.binput = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsglinkatpositionresponse() CMsgLinkAtPositionResponse { +return CMsgLinkAtPositionResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsglinkatpositionresponse(o CMsgLinkAtPositionResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsglinkatpositionresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgLinkAtPositionResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsglinkatpositionresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgZoomToElementAtPosition { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +x u32 +has_x bool +y u32 +has_y bool +} +pub fn (o &CMsgZoomToElementAtPosition) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_x { +res << vproto.pack_uint32_field(o.x, 2) +} + +if o.has_y { +res << vproto.pack_uint32_field(o.y, 3) +} + +return res +} + +pub fn cmsgzoomtoelementatposition_unpack(buf []byte) ?CMsgZoomToElementAtPosition { +mut res := CMsgZoomToElementAtPosition{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_x = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.x = v +i = ii +} + +3 { +res.has_y = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.y = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgzoomtoelementatposition() CMsgZoomToElementAtPosition { +return CMsgZoomToElementAtPosition{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgzoomtoelementatposition(o CMsgZoomToElementAtPosition, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgzoomtoelementatposition(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgZoomToElementAtPosition) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgzoomtoelementatposition_unpack(v)? +return i, unpacked +} +pub struct CMsgZoomToElementAtPositionResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +scale f32 +has_scale bool +duration f32 +has_duration bool +} +pub fn (o &CMsgZoomToElementAtPositionResponse) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_scale { +res << vproto.pack_float_field(o.scale, 2) +} + +if o.has_duration { +res << vproto.pack_float_field(o.duration, 3) +} + +return res +} + +pub fn cmsgzoomtoelementatpositionresponse_unpack(buf []byte) ?CMsgZoomToElementAtPositionResponse { +mut res := CMsgZoomToElementAtPositionResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_scale = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.scale = v +i = ii +} + +3 { +res.has_duration = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.duration = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgzoomtoelementatpositionresponse() CMsgZoomToElementAtPositionResponse { +return CMsgZoomToElementAtPositionResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgzoomtoelementatpositionresponse(o CMsgZoomToElementAtPositionResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgzoomtoelementatpositionresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgZoomToElementAtPositionResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgzoomtoelementatpositionresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgScalePageToValue { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +scale f32 +has_scale bool +x f32 +has_x bool +y f32 +has_y bool +} +pub fn (o &CMsgScalePageToValue) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_scale { +res << vproto.pack_float_field(o.scale, 2) +} + +if o.has_x { +res << vproto.pack_float_field(o.x, 3) +} + +if o.has_y { +res << vproto.pack_float_field(o.y, 4) +} + +return res +} + +pub fn cmsgscalepagetovalue_unpack(buf []byte) ?CMsgScalePageToValue { +mut res := CMsgScalePageToValue{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_scale = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.scale = v +i = ii +} + +3 { +res.has_x = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.x = v +i = ii +} + +4 { +res.has_y = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.y = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgscalepagetovalue() CMsgScalePageToValue { +return CMsgScalePageToValue{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgscalepagetovalue(o CMsgScalePageToValue, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgscalepagetovalue(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgScalePageToValue) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgscalepagetovalue_unpack(v)? +return i, unpacked +} +pub struct CMsgForcePopupsToDirectHWnd { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +force_direct_hwnd_popups bool +has_force_direct_hwnd_popups bool +} +pub fn (o &CMsgForcePopupsToDirectHWnd) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_force_direct_hwnd_popups { +res << vproto.pack_bool_field(o.force_direct_hwnd_popups, 2) +} + +return res +} + +pub fn cmsgforcepopupstodirecthwnd_unpack(buf []byte) ?CMsgForcePopupsToDirectHWnd { +mut res := CMsgForcePopupsToDirectHWnd{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_force_direct_hwnd_popups = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.force_direct_hwnd_popups = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgforcepopupstodirecthwnd() CMsgForcePopupsToDirectHWnd { +return CMsgForcePopupsToDirectHWnd{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgforcepopupstodirecthwnd(o CMsgForcePopupsToDirectHWnd, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgforcepopupstodirecthwnd(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgForcePopupsToDirectHWnd) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgforcepopupstodirecthwnd_unpack(v)? +return i, unpacked +} +pub struct CMsgScalePageToValueResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +zoom f32 +has_zoom bool +} +pub fn (o &CMsgScalePageToValueResponse) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_zoom { +res << vproto.pack_float_field(o.zoom, 2) +} + +return res +} + +pub fn cmsgscalepagetovalueresponse_unpack(buf []byte) ?CMsgScalePageToValueResponse { +mut res := CMsgScalePageToValueResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_zoom = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.zoom = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgscalepagetovalueresponse() CMsgScalePageToValueResponse { +return CMsgScalePageToValueResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgscalepagetovalueresponse(o CMsgScalePageToValueResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgscalepagetovalueresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgScalePageToValueResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgscalepagetovalueresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgSavePageToJPeg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +url string +has_url bool +filename string +has_filename bool +width u32 +has_width bool +height u32 +has_height bool +} +pub fn (o &CMsgSavePageToJPeg) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_url { +res << vproto.pack_string_field(o.url, 2) +} + +if o.has_filename { +res << vproto.pack_string_field(o.filename, 3) +} + +if o.has_width { +res << vproto.pack_uint32_field(o.width, 4) +} + +if o.has_height { +res << vproto.pack_uint32_field(o.height, 5) +} + +return res +} + +pub fn cmsgsavepagetojpeg_unpack(buf []byte) ?CMsgSavePageToJPeg { +mut res := CMsgSavePageToJPeg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url = v +i = ii +} + +3 { +res.has_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.filename = v +i = ii +} + +4 { +res.has_width = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.width = v +i = ii +} + +5 { +res.has_height = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.height = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsavepagetojpeg() CMsgSavePageToJPeg { +return CMsgSavePageToJPeg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsavepagetojpeg(o CMsgSavePageToJPeg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsavepagetojpeg(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSavePageToJPeg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsavepagetojpeg_unpack(v)? +return i, unpacked +} +pub struct CMsgSavePageToJPegresponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +url string +has_url bool +filename string +has_filename bool +} +pub fn (o &CMsgSavePageToJPegresponse) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_url { +res << vproto.pack_string_field(o.url, 2) +} + +if o.has_filename { +res << vproto.pack_string_field(o.filename, 3) +} + +return res +} + +pub fn cmsgsavepagetojpegresponse_unpack(buf []byte) ?CMsgSavePageToJPegresponse { +mut res := CMsgSavePageToJPegresponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url = v +i = ii +} + +3 { +res.has_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.filename = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsavepagetojpegresponse() CMsgSavePageToJPegresponse { +return CMsgSavePageToJPegresponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsavepagetojpegresponse(o CMsgSavePageToJPegresponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsavepagetojpegresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSavePageToJPegresponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsavepagetojpegresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgJSalert { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +message string +has_message bool +} +pub fn (o &CMsgJSalert) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_message { +res << vproto.pack_string_field(o.message, 2) +} + +return res +} + +pub fn cmsgjsalert_unpack(buf []byte) ?CMsgJSalert { +mut res := CMsgJSalert{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_message = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.message = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgjsalert() CMsgJSalert { +return CMsgJSalert{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgjsalert(o CMsgJSalert, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgjsalert(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgJSalert) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgjsalert_unpack(v)? +return i, unpacked +} +pub struct CMsgJSconfirm { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +message string +has_message bool +} +pub fn (o &CMsgJSconfirm) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_message { +res << vproto.pack_string_field(o.message, 2) +} + +return res +} + +pub fn cmsgjsconfirm_unpack(buf []byte) ?CMsgJSconfirm { +mut res := CMsgJSconfirm{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_message = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.message = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgjsconfirm() CMsgJSconfirm { +return CMsgJSconfirm{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgjsconfirm(o CMsgJSconfirm, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgjsconfirm(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgJSconfirm) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgjsconfirm_unpack(v)? +return i, unpacked +} +pub struct CMsgJSdialogResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +result bool +has_result bool +} +pub fn (o &CMsgJSdialogResponse) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_result { +res << vproto.pack_bool_field(o.result, 2) +} + +return res +} + +pub fn cmsgjsdialogresponse_unpack(buf []byte) ?CMsgJSdialogResponse { +mut res := CMsgJSdialogResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_result = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.result = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgjsdialogresponse() CMsgJSdialogResponse { +return CMsgJSdialogResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgjsdialogresponse(o CMsgJSdialogResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgjsdialogresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgJSdialogResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgjsdialogresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgCanGoBackAndForward { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +bgoback bool +has_bgoback bool +bgoforward bool +has_bgoforward bool +} +pub fn (o &CMsgCanGoBackAndForward) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_bgoback { +res << vproto.pack_bool_field(o.bgoback, 2) +} + +if o.has_bgoforward { +res << vproto.pack_bool_field(o.bgoforward, 3) +} + +return res +} + +pub fn cmsgcangobackandforward_unpack(buf []byte) ?CMsgCanGoBackAndForward { +mut res := CMsgCanGoBackAndForward{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_bgoback = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.bgoback = v +i = ii +} + +3 { +res.has_bgoforward = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.bgoforward = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgcangobackandforward() CMsgCanGoBackAndForward { +return CMsgCanGoBackAndForward{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgcangobackandforward(o CMsgCanGoBackAndForward, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgcangobackandforward(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgCanGoBackAndForward) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgcangobackandforward_unpack(v)? +return i, unpacked +} +pub struct CMsgOpenSteamURl { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +url string +has_url bool +referrer string +has_referrer bool +} +pub fn (o &CMsgOpenSteamURl) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_url { +res << vproto.pack_string_field(o.url, 2) +} + +if o.has_referrer { +res << vproto.pack_string_field(o.referrer, 3) +} + +return res +} + +pub fn cmsgopensteamurl_unpack(buf []byte) ?CMsgOpenSteamURl { +mut res := CMsgOpenSteamURl{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url = v +i = ii +} + +3 { +res.has_referrer = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.referrer = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgopensteamurl() CMsgOpenSteamURl { +return CMsgOpenSteamURl{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgopensteamurl(o CMsgOpenSteamURl, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgopensteamurl(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgOpenSteamURl) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgopensteamurl_unpack(v)? +return i, unpacked +} +pub struct CMsgSetCookie { +mut: +unknown_fields []vproto.UnknownField +pub mut: +key string +has_key bool +value string +has_value bool +path string +has_path bool +host string +has_host bool +expires u32 +has_expires bool +secure bool +has_secure bool +httponly bool +has_httponly bool +} +pub fn (o &CMsgSetCookie) pack() []byte { +mut res := []byte{} +if o.has_key { +res << vproto.pack_string_field(o.key, 1) +} + +if o.has_value { +res << vproto.pack_string_field(o.value, 2) +} + +if o.has_path { +res << vproto.pack_string_field(o.path, 3) +} + +if o.has_host { +res << vproto.pack_string_field(o.host, 4) +} + +if o.has_expires { +res << vproto.pack_uint32_field(o.expires, 5) +} + +if o.has_secure { +res << vproto.pack_bool_field(o.secure, 6) +} + +if o.has_httponly { +res << vproto.pack_bool_field(o.httponly, 7) +} + +return res +} + +pub fn cmsgsetcookie_unpack(buf []byte) ?CMsgSetCookie { +mut res := CMsgSetCookie{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_key = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.key = v +i = ii +} + +2 { +res.has_value = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.value = v +i = ii +} + +3 { +res.has_path = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.path = v +i = ii +} + +4 { +res.has_host = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.host = v +i = ii +} + +5 { +res.has_expires = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.expires = v +i = ii +} + +6 { +res.has_secure = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.secure = v +i = ii +} + +7 { +res.has_httponly = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.httponly = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsetcookie() CMsgSetCookie { +return CMsgSetCookie{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsetcookie(o CMsgSetCookie, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsetcookie(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSetCookie) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsetcookie_unpack(v)? +return i, unpacked +} +pub struct CMsgSetTargetFrameRate { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +ntargetframerate u32 +has_ntargetframerate bool +} +pub fn (o &CMsgSetTargetFrameRate) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_ntargetframerate { +res << vproto.pack_uint32_field(o.ntargetframerate, 2) +} + +return res +} + +pub fn cmsgsettargetframerate_unpack(buf []byte) ?CMsgSetTargetFrameRate { +mut res := CMsgSetTargetFrameRate{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_ntargetframerate = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ntargetframerate = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsettargetframerate() CMsgSetTargetFrameRate { +return CMsgSetTargetFrameRate{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsettargetframerate(o CMsgSetTargetFrameRate, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsettargetframerate(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSetTargetFrameRate) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsettargetframerate_unpack(v)? +return i, unpacked +} +pub struct CMsgPauseRepaint { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgPauseRepaint) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgpauserepaint_unpack(buf []byte) ?CMsgPauseRepaint { +mut res := CMsgPauseRepaint{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgpauserepaint() CMsgPauseRepaint { +return CMsgPauseRepaint{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgpauserepaint(o CMsgPauseRepaint, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgpauserepaint(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgPauseRepaint) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgpauserepaint_unpack(v)? +return i, unpacked +} +pub struct CMsgFullRepaint { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgFullRepaint) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgfullrepaint_unpack(buf []byte) ?CMsgFullRepaint { +mut res := CMsgFullRepaint{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgfullrepaint() CMsgFullRepaint { +return CMsgFullRepaint{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgfullrepaint(o CMsgFullRepaint, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgfullrepaint(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgFullRepaint) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgfullrepaint_unpack(v)? +return i, unpacked +} +pub struct CMsgRequestFullScreen { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgRequestFullScreen) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgrequestfullscreen_unpack(buf []byte) ?CMsgRequestFullScreen { +mut res := CMsgRequestFullScreen{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgrequestfullscreen() CMsgRequestFullScreen { +return CMsgRequestFullScreen{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgrequestfullscreen(o CMsgRequestFullScreen, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgrequestfullscreen(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRequestFullScreen) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgrequestfullscreen_unpack(v)? +return i, unpacked +} +pub struct CMsgExitFullScreen { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgExitFullScreen) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgexitfullscreen_unpack(buf []byte) ?CMsgExitFullScreen { +mut res := CMsgExitFullScreen{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgexitfullscreen() CMsgExitFullScreen { +return CMsgExitFullScreen{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgexitfullscreen(o CMsgExitFullScreen, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgexitfullscreen(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgExitFullScreen) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgexitfullscreen_unpack(v)? +return i, unpacked +} +pub struct CMsgToggleFindInPageDialog { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgToggleFindInPageDialog) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgtogglefindinpagedialog_unpack(buf []byte) ?CMsgToggleFindInPageDialog { +mut res := CMsgToggleFindInPageDialog{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgtogglefindinpagedialog() CMsgToggleFindInPageDialog { +return CMsgToggleFindInPageDialog{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgtogglefindinpagedialog(o CMsgToggleFindInPageDialog, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgtogglefindinpagedialog(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgToggleFindInPageDialog) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgtogglefindinpagedialog_unpack(v)? +return i, unpacked +} +pub struct CMsgSetPIdshuttingDown { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgSetPIdshuttingDown) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgsetpidshuttingdown_unpack(buf []byte) ?CMsgSetPIdshuttingDown { +mut res := CMsgSetPIdshuttingDown{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsetpidshuttingdown() CMsgSetPIdshuttingDown { +return CMsgSetPIdshuttingDown{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsetpidshuttingdown(o CMsgSetPIdshuttingDown, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsetpidshuttingdown(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSetPIdshuttingDown) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsetpidshuttingdown_unpack(v)? +return i, unpacked +} +pub struct CMsgDisableBackgroundThrottling { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgDisableBackgroundThrottling) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgdisablebackgroundthrottling_unpack(buf []byte) ?CMsgDisableBackgroundThrottling { +mut res := CMsgDisableBackgroundThrottling{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgdisablebackgroundthrottling() CMsgDisableBackgroundThrottling { +return CMsgDisableBackgroundThrottling{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgdisablebackgroundthrottling(o CMsgDisableBackgroundThrottling, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgdisablebackgroundthrottling(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgDisableBackgroundThrottling) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgdisablebackgroundthrottling_unpack(v)? +return i, unpacked +} +pub struct CMsgAckPIdshuttingDown { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgAckPIdshuttingDown) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgackpidshuttingdown_unpack(buf []byte) ?CMsgAckPIdshuttingDown { +mut res := CMsgAckPIdshuttingDown{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgackpidshuttingdown() CMsgAckPIdshuttingDown { +return CMsgAckPIdshuttingDown{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgackpidshuttingdown(o CMsgAckPIdshuttingDown, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgackpidshuttingdown(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgAckPIdshuttingDown) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgackpidshuttingdown_unpack(v)? +return i, unpacked +} +pub struct CMsgGetCookiesForURl { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +url string +has_url bool +} +pub fn (o &CMsgGetCookiesForURl) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_url { +res << vproto.pack_string_field(o.url, 2) +} + +return res +} + +pub fn cmsggetcookiesforurl_unpack(buf []byte) ?CMsgGetCookiesForURl { +mut res := CMsgGetCookiesForURl{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggetcookiesforurl() CMsgGetCookiesForURl { +return CMsgGetCookiesForURl{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggetcookiesforurl(o CMsgGetCookiesForURl, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggetcookiesforurl(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGetCookiesForURl) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggetcookiesforurl_unpack(v)? +return i, unpacked +} +pub struct CCookie { +mut: +unknown_fields []vproto.UnknownField +pub mut: +name string +has_name bool +value string +has_value bool +domain string +has_domain bool +path string +has_path bool +} +pub fn (o &CCookie) pack() []byte { +mut res := []byte{} +if o.has_name { +res << vproto.pack_string_field(o.name, 1) +} + +if o.has_value { +res << vproto.pack_string_field(o.value, 2) +} + +if o.has_domain { +res << vproto.pack_string_field(o.domain, 3) +} + +if o.has_path { +res << vproto.pack_string_field(o.path, 4) +} + +return res +} + +pub fn ccookie_unpack(buf []byte) ?CCookie { +mut res := CCookie{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +2 { +res.has_value = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.value = v +i = ii +} + +3 { +res.has_domain = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.domain = v +i = ii +} + +4 { +res.has_path = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.path = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccookie() CCookie { +return CCookie{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccookie(o CCookie, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccookie(buf []byte, tag_wiretype vproto.WireType) ?(int, CCookie) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccookie_unpack(v)? +return i, unpacked +} +pub struct CMsgGetCookiesForURlresponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +url string +has_url bool +cookies []CCookie +} +pub fn (o &CMsgGetCookiesForURlresponse) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_url { +res << vproto.pack_string_field(o.url, 2) +} + +// [packed=false] +for _, x in o.cookies { +res << zzz_vproto_internal_pack_ccookie(x, 3) +} + +return res +} + +pub fn cmsggetcookiesforurlresponse_unpack(buf []byte) ?CMsgGetCookiesForURlresponse { +mut res := CMsgGetCookiesForURlresponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_ccookie(cur_buf, tag_wiretype.wire_type)? +res.cookies << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggetcookiesforurlresponse() CMsgGetCookiesForURlresponse { +return CMsgGetCookiesForURlresponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggetcookiesforurlresponse(o CMsgGetCookiesForURlresponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggetcookiesforurlresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGetCookiesForURlresponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggetcookiesforurlresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgNodeHasFocus { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +binput bool +has_binput bool +name string +has_name bool +elementtagname string +has_elementtagname bool +searchbuttontext string +has_searchbuttontext bool +bhasmultipleinputs bool +has_bhasmultipleinputs bool +input_type string +has_input_type bool +} +pub fn (o &CMsgNodeHasFocus) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_binput { +res << vproto.pack_bool_field(o.binput, 2) +} + +if o.has_name { +res << vproto.pack_string_field(o.name, 3) +} + +if o.has_elementtagname { +res << vproto.pack_string_field(o.elementtagname, 4) +} + +if o.has_searchbuttontext { +res << vproto.pack_string_field(o.searchbuttontext, 5) +} + +if o.has_bhasmultipleinputs { +res << vproto.pack_bool_field(o.bhasmultipleinputs, 6) +} + +if o.has_input_type { +res << vproto.pack_string_field(o.input_type, 7) +} + +return res +} + +pub fn cmsgnodehasfocus_unpack(buf []byte) ?CMsgNodeHasFocus { +mut res := CMsgNodeHasFocus{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_binput = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.binput = v +i = ii +} + +3 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +4 { +res.has_elementtagname = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.elementtagname = v +i = ii +} + +5 { +res.has_searchbuttontext = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.searchbuttontext = v +i = ii +} + +6 { +res.has_bhasmultipleinputs = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.bhasmultipleinputs = v +i = ii +} + +7 { +res.has_input_type = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.input_type = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgnodehasfocus() CMsgNodeHasFocus { +return CMsgNodeHasFocus{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgnodehasfocus(o CMsgNodeHasFocus, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgnodehasfocus(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgNodeHasFocus) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgnodehasfocus_unpack(v)? +return i, unpacked +} +pub struct CMsgZoomToFocusedElement { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgZoomToFocusedElement) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgzoomtofocusedelement_unpack(buf []byte) ?CMsgZoomToFocusedElement { +mut res := CMsgZoomToFocusedElement{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgzoomtofocusedelement() CMsgZoomToFocusedElement { +return CMsgZoomToFocusedElement{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgzoomtofocusedelement(o CMsgZoomToFocusedElement, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgzoomtofocusedelement(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgZoomToFocusedElement) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgzoomtofocusedelement_unpack(v)? +return i, unpacked +} +pub struct CMsgCloseFullScreenFlashIfOpen { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgCloseFullScreenFlashIfOpen) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgclosefullscreenflashifopen_unpack(buf []byte) ?CMsgCloseFullScreenFlashIfOpen { +mut res := CMsgCloseFullScreenFlashIfOpen{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclosefullscreenflashifopen() CMsgCloseFullScreenFlashIfOpen { +return CMsgCloseFullScreenFlashIfOpen{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclosefullscreenflashifopen(o CMsgCloseFullScreenFlashIfOpen, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclosefullscreenflashifopen(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgCloseFullScreenFlashIfOpen) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclosefullscreenflashifopen_unpack(v)? +return i, unpacked +} +pub struct CMsgPauseFullScreenFlashMovieIfOpen { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgPauseFullScreenFlashMovieIfOpen) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgpausefullscreenflashmovieifopen_unpack(buf []byte) ?CMsgPauseFullScreenFlashMovieIfOpen { +mut res := CMsgPauseFullScreenFlashMovieIfOpen{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgpausefullscreenflashmovieifopen() CMsgPauseFullScreenFlashMovieIfOpen { +return CMsgPauseFullScreenFlashMovieIfOpen{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgpausefullscreenflashmovieifopen(o CMsgPauseFullScreenFlashMovieIfOpen, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgpausefullscreenflashmovieifopen(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgPauseFullScreenFlashMovieIfOpen) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgpausefullscreenflashmovieifopen_unpack(v)? +return i, unpacked +} +pub struct CMsgFocusedNodeText { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgFocusedNodeText) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgfocusednodetext_unpack(buf []byte) ?CMsgFocusedNodeText { +mut res := CMsgFocusedNodeText{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgfocusednodetext() CMsgFocusedNodeText { +return CMsgFocusedNodeText{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgfocusednodetext(o CMsgFocusedNodeText, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgfocusednodetext(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgFocusedNodeText) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgfocusednodetext_unpack(v)? +return i, unpacked +} +pub struct CMsgFocusedNodeTextResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +value string +has_value bool +} +pub fn (o &CMsgFocusedNodeTextResponse) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_value { +res << vproto.pack_string_field(o.value, 2) +} + +return res +} + +pub fn cmsgfocusednodetextresponse_unpack(buf []byte) ?CMsgFocusedNodeTextResponse { +mut res := CMsgFocusedNodeTextResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_value = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.value = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgfocusednodetextresponse() CMsgFocusedNodeTextResponse { +return CMsgFocusedNodeTextResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgfocusednodetextresponse(o CMsgFocusedNodeTextResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgfocusednodetextresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgFocusedNodeTextResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgfocusednodetextresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgBuildID { +mut: +unknown_fields []vproto.UnknownField +pub mut: +build_id u64 +has_build_id bool +} +pub fn (o &CMsgBuildID) pack() []byte { +mut res := []byte{} +if o.has_build_id { +res << vproto.pack_uint64_field(o.build_id, 1) +} + +return res +} + +pub fn cmsgbuildid_unpack(buf []byte) ?CMsgBuildID { +mut res := CMsgBuildID{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_build_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.build_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgbuildid() CMsgBuildID { +return CMsgBuildID{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgbuildid(o CMsgBuildID, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgbuildid(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgBuildID) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgbuildid_unpack(v)? +return i, unpacked +} +pub struct CMsgOpenDevTools { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgOpenDevTools) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgopendevtools_unpack(buf []byte) ?CMsgOpenDevTools { +mut res := CMsgOpenDevTools{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgopendevtools() CMsgOpenDevTools { +return CMsgOpenDevTools{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgopendevtools(o CMsgOpenDevTools, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgopendevtools(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgOpenDevTools) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgopendevtools_unpack(v)? +return i, unpacked +} +pub struct CMsgCloseDevTools { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgCloseDevTools) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgclosedevtools_unpack(buf []byte) ?CMsgCloseDevTools { +mut res := CMsgCloseDevTools{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclosedevtools() CMsgCloseDevTools { +return CMsgCloseDevTools{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclosedevtools(o CMsgCloseDevTools, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclosedevtools(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgCloseDevTools) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclosedevtools_unpack(v)? +return i, unpacked +} +pub struct CMsgUnlockH264 { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +unlock_code string +has_unlock_code bool +} +pub fn (o &CMsgUnlockH264) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_unlock_code { +res << vproto.pack_string_field(o.unlock_code, 2) +} + +return res +} + +pub fn cmsgunlockh264_unpack(buf []byte) ?CMsgUnlockH264 { +mut res := CMsgUnlockH264{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_unlock_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.unlock_code = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgunlockh264() CMsgUnlockH264 { +return CMsgUnlockH264{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgunlockh264(o CMsgUnlockH264, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgunlockh264(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgUnlockH264) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgunlockh264_unpack(v)? +return i, unpacked +} +pub struct CMsgScreenInformationChanged { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +override_width u32 +has_override_width bool +override_height u32 +has_override_height bool +monitor_left u32 +has_monitor_left bool +monitor_top u32 +has_monitor_top bool +monitor_right u32 +has_monitor_right bool +monitor_bottom u32 +has_monitor_bottom bool +usable_left u32 +has_usable_left bool +usable_top u32 +has_usable_top bool +usable_right u32 +has_usable_right bool +usable_bottom u32 +has_usable_bottom bool +} +pub fn (o &CMsgScreenInformationChanged) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_override_width { +res << vproto.pack_uint32_field(o.override_width, 2) +} + +if o.has_override_height { +res << vproto.pack_uint32_field(o.override_height, 3) +} + +if o.has_monitor_left { +res << vproto.pack_uint32_field(o.monitor_left, 4) +} + +if o.has_monitor_top { +res << vproto.pack_uint32_field(o.monitor_top, 5) +} + +if o.has_monitor_right { +res << vproto.pack_uint32_field(o.monitor_right, 6) +} + +if o.has_monitor_bottom { +res << vproto.pack_uint32_field(o.monitor_bottom, 7) +} + +if o.has_usable_left { +res << vproto.pack_uint32_field(o.usable_left, 8) +} + +if o.has_usable_top { +res << vproto.pack_uint32_field(o.usable_top, 9) +} + +if o.has_usable_right { +res << vproto.pack_uint32_field(o.usable_right, 10) +} + +if o.has_usable_bottom { +res << vproto.pack_uint32_field(o.usable_bottom, 11) +} + +return res +} + +pub fn cmsgscreeninformationchanged_unpack(buf []byte) ?CMsgScreenInformationChanged { +mut res := CMsgScreenInformationChanged{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_override_width = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.override_width = v +i = ii +} + +3 { +res.has_override_height = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.override_height = v +i = ii +} + +4 { +res.has_monitor_left = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.monitor_left = v +i = ii +} + +5 { +res.has_monitor_top = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.monitor_top = v +i = ii +} + +6 { +res.has_monitor_right = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.monitor_right = v +i = ii +} + +7 { +res.has_monitor_bottom = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.monitor_bottom = v +i = ii +} + +8 { +res.has_usable_left = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.usable_left = v +i = ii +} + +9 { +res.has_usable_top = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.usable_top = v +i = ii +} + +10 { +res.has_usable_right = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.usable_right = v +i = ii +} + +11 { +res.has_usable_bottom = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.usable_bottom = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgscreeninformationchanged() CMsgScreenInformationChanged { +return CMsgScreenInformationChanged{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgscreeninformationchanged(o CMsgScreenInformationChanged, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgscreeninformationchanged(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgScreenInformationChanged) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgscreeninformationchanged_unpack(v)? +return i, unpacked +} +pub struct CMsgClearAllCookies { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgClearAllCookies) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgclearallcookies_unpack(buf []byte) ?CMsgClearAllCookies { +mut res := CMsgClearAllCookies{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclearallcookies() CMsgClearAllCookies { +return CMsgClearAllCookies{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclearallcookies(o CMsgClearAllCookies, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclearallcookies(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClearAllCookies) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclearallcookies_unpack(v)? +return i, unpacked +} +pub struct CMsgScreenDPi { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +dpi_scaling f32 +has_dpi_scaling bool +} +pub fn (o &CMsgScreenDPi) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_dpi_scaling { +res << vproto.pack_float_field(o.dpi_scaling, 2) +} + +return res +} + +pub fn cmsgscreendpi_unpack(buf []byte) ?CMsgScreenDPi { +mut res := CMsgScreenDPi{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_dpi_scaling = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.dpi_scaling = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgscreendpi() CMsgScreenDPi { +return CMsgScreenDPi{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgscreendpi(o CMsgScreenDPi, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgscreendpi(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgScreenDPi) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgscreendpi_unpack(v)? +return i, unpacked +} +pub struct CMsgAuthedSteamDomains { +mut: +unknown_fields []vproto.UnknownField +pub mut: +domains []string +} +pub fn (o &CMsgAuthedSteamDomains) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.domains { +res << vproto.pack_string_field(x, 1) +} + +return res +} + +pub fn cmsgauthedsteamdomains_unpack(buf []byte) ?CMsgAuthedSteamDomains { +mut res := CMsgAuthedSteamDomains{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.domains << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgauthedsteamdomains() CMsgAuthedSteamDomains { +return CMsgAuthedSteamDomains{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgauthedsteamdomains(o CMsgAuthedSteamDomains, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgauthedsteamdomains(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgAuthedSteamDomains) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgauthedsteamdomains_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamAuthNeeded { +mut: +unknown_fields []vproto.UnknownField +pub mut: +filler bool +has_filler bool +} +pub fn (o &CMsgSteamAuthNeeded) pack() []byte { +mut res := []byte{} +if o.has_filler { +res << vproto.pack_bool_field(o.filler, 1) +} + +return res +} + +pub fn cmsgsteamauthneeded_unpack(buf []byte) ?CMsgSteamAuthNeeded { +mut res := CMsgSteamAuthNeeded{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_filler = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.filler = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamauthneeded() CMsgSteamAuthNeeded { +return CMsgSteamAuthNeeded{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamauthneeded(o CMsgSteamAuthNeeded, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamauthneeded(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamAuthNeeded) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamauthneeded_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamAuthCookiesSet { +mut: +unknown_fields []vproto.UnknownField +pub mut: +success bool +has_success bool +} +pub fn (o &CMsgSteamAuthCookiesSet) pack() []byte { +mut res := []byte{} +if o.has_success { +res << vproto.pack_bool_field(o.success, 1) +} + +return res +} + +pub fn cmsgsteamauthcookiesset_unpack(buf []byte) ?CMsgSteamAuthCookiesSet { +mut res := CMsgSteamAuthCookiesSet{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_success = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.success = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamauthcookiesset() CMsgSteamAuthCookiesSet { +return CMsgSteamAuthCookiesSet{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamauthcookiesset(o CMsgSteamAuthCookiesSet, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamauthcookiesset(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamAuthCookiesSet) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamauthcookiesset_unpack(v)? +return i, unpacked +} +pub struct CMsgJSregisterMethod { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +name string +has_name bool +method_type EJsregisterMethodType +has_method_type bool +} +pub fn (o &CMsgJSregisterMethod) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_name { +res << vproto.pack_string_field(o.name, 2) +} + +if o.has_method_type { +res << zzz_vproto_internal_pack_ejsregistermethodtype(o.method_type, 3) +} + +return res +} + +pub fn cmsgjsregistermethod_unpack(buf []byte) ?CMsgJSregisterMethod { +mut res := CMsgJSregisterMethod{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +3 { +res.has_method_type = true +ii, v := zzz_vproto_internal_unpack_ejsregistermethodtype(cur_buf, tag_wiretype.wire_type)? +res.method_type = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgjsregistermethod() CMsgJSregisterMethod { +return CMsgJSregisterMethod{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgjsregistermethod(o CMsgJSregisterMethod, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgjsregistermethod(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgJSregisterMethod) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgjsregistermethod_unpack(v)? +return i, unpacked +} +pub struct CJsmethodArgument { +mut: +unknown_fields []vproto.UnknownField +pub mut: +json_data string +has_json_data bool +function_handle u64 +has_function_handle bool +} +pub fn (o &CJsmethodArgument) pack() []byte { +mut res := []byte{} +if o.has_json_data { +res << vproto.pack_string_field(o.json_data, 1) +} + +if o.has_function_handle { +res << vproto.pack_uint64_field(o.function_handle, 2) +} + +return res +} + +pub fn cjsmethodargument_unpack(buf []byte) ?CJsmethodArgument { +mut res := CJsmethodArgument{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_json_data = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.json_data = v +i = ii +} + +2 { +res.has_function_handle = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.function_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cjsmethodargument() CJsmethodArgument { +return CJsmethodArgument{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cjsmethodargument(o CJsmethodArgument, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cjsmethodargument(buf []byte, tag_wiretype vproto.WireType) ?(int, CJsmethodArgument) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cjsmethodargument_unpack(v)? +return i, unpacked +} +pub struct CMsgJSvalueJSobjectProperty { +mut: +unknown_fields []vproto.UnknownField +pub mut: +name string +has_name bool +value CMsgJSvalue +has_value bool +} +pub fn (o &CMsgJSvalueJSobjectProperty) pack() []byte { +mut res := []byte{} +if o.has_name { +res << vproto.pack_string_field(o.name, 1) +} + +if o.has_value { +res << zzz_vproto_internal_pack_cmsgjsvalue(o.value, 2) +} + +return res +} + +pub fn cmsgjsvaluejsobjectproperty_unpack(buf []byte) ?CMsgJSvalueJSobjectProperty { +mut res := CMsgJSvalueJSobjectProperty{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +2 { +res.has_value = true +ii, v := zzz_vproto_internal_unpack_cmsgjsvalue(cur_buf, tag_wiretype.wire_type)? +res.value = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgjsvaluejsobjectproperty() CMsgJSvalueJSobjectProperty { +return CMsgJSvalueJSobjectProperty{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgjsvaluejsobjectproperty(o CMsgJSvalueJSobjectProperty, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgjsvaluejsobjectproperty(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgJSvalueJSobjectProperty) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgjsvaluejsobjectproperty_unpack(v)? +return i, unpacked +} +pub struct CMsgJSvalue { +mut: +unknown_fields []vproto.UnknownField +pub mut: +bool_value bool +has_bool_value bool +int_value int +has_int_value bool +uint_value u32 +has_uint_value bool +double_value f64 +has_double_value bool +string_value string +has_string_value bool +function_handle u64 +has_function_handle bool +is_array bool +has_is_array bool +array_values []CMsgJSvalue +is_object bool +has_is_object bool +object_properties []CMsgJSvalueJSobjectProperty +} +pub fn (o &CMsgJSvalue) pack() []byte { +mut res := []byte{} +if o.has_bool_value { +res << vproto.pack_bool_field(o.bool_value, 1) +} + +if o.has_int_value { +res << vproto.pack_int32_field(o.int_value, 2) +} + +if o.has_uint_value { +res << vproto.pack_uint32_field(o.uint_value, 3) +} + +if o.has_double_value { +res << vproto.pack_double_field(o.double_value, 4) +} + +if o.has_string_value { +res << vproto.pack_string_field(o.string_value, 5) +} + +if o.has_function_handle { +res << vproto.pack_uint64_field(o.function_handle, 6) +} + +if o.has_is_array { +res << vproto.pack_bool_field(o.is_array, 8) +} + +// [packed=false] +for _, x in o.array_values { +res << zzz_vproto_internal_pack_cmsgjsvalue(x, 9) +} + +if o.has_is_object { +res << vproto.pack_bool_field(o.is_object, 10) +} + +// [packed=false] +for _, x in o.object_properties { +res << zzz_vproto_internal_pack_cmsgjsvaluejsobjectproperty(x, 11) +} + +return res +} + +pub fn cmsgjsvalue_unpack(buf []byte) ?CMsgJSvalue { +mut res := CMsgJSvalue{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_bool_value = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.bool_value = v +i = ii +} + +2 { +res.has_int_value = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.int_value = v +i = ii +} + +3 { +res.has_uint_value = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.uint_value = v +i = ii +} + +4 { +res.has_double_value = true +ii, v := vproto.unpack_double_field(cur_buf, tag_wiretype.wire_type)? +res.double_value = v +i = ii +} + +5 { +res.has_string_value = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.string_value = v +i = ii +} + +6 { +res.has_function_handle = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.function_handle = v +i = ii +} + +8 { +res.has_is_array = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_array = v +i = ii +} + +9 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgjsvalue(cur_buf, tag_wiretype.wire_type)? +res.array_values << v +i = ii +} + +10 { +res.has_is_object = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_object = v +i = ii +} + +11 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgjsvaluejsobjectproperty(cur_buf, tag_wiretype.wire_type)? +res.object_properties << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgjsvalue() CMsgJSvalue { +return CMsgJSvalue{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgjsvalue(o CMsgJSvalue, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgjsvalue(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgJSvalue) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgjsvalue_unpack(v)? +return i, unpacked +} +pub struct CMsgJSmethodCall { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +name string +has_name bool +arguments []CMsgJSvalue +} +pub fn (o &CMsgJSmethodCall) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_name { +res << vproto.pack_string_field(o.name, 2) +} + +// [packed=false] +for _, x in o.arguments { +res << zzz_vproto_internal_pack_cmsgjsvalue(x, 3) +} + +return res +} + +pub fn cmsgjsmethodcall_unpack(buf []byte) ?CMsgJSmethodCall { +mut res := CMsgJSmethodCall{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgjsvalue(cur_buf, tag_wiretype.wire_type)? +res.arguments << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgjsmethodcall() CMsgJSmethodCall { +return CMsgJSmethodCall{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgjsmethodcall(o CMsgJSmethodCall, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgjsmethodcall(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgJSmethodCall) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgjsmethodcall_unpack(v)? +return i, unpacked +} +pub struct CMsgJSexecuteCallback { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +function_handle u64 +has_function_handle bool +arguments []CMsgJSvalue +} +pub fn (o &CMsgJSexecuteCallback) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_function_handle { +res << vproto.pack_uint64_field(o.function_handle, 2) +} + +// [packed=false] +for _, x in o.arguments { +res << zzz_vproto_internal_pack_cmsgjsvalue(x, 3) +} + +return res +} + +pub fn cmsgjsexecutecallback_unpack(buf []byte) ?CMsgJSexecuteCallback { +mut res := CMsgJSexecuteCallback{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_function_handle = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.function_handle = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgjsvalue(cur_buf, tag_wiretype.wire_type)? +res.arguments << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgjsexecutecallback() CMsgJSexecuteCallback { +return CMsgJSexecuteCallback{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgjsexecutecallback(o CMsgJSexecuteCallback, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgjsexecutecallback(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgJSexecuteCallback) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgjsexecutecallback_unpack(v)? +return i, unpacked +} +pub struct CMsgJSreleaseCallback { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +function_handle u64 +has_function_handle bool +} +pub fn (o &CMsgJSreleaseCallback) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_function_handle { +res << vproto.pack_uint64_field(o.function_handle, 2) +} + +return res +} + +pub fn cmsgjsreleasecallback_unpack(buf []byte) ?CMsgJSreleaseCallback { +mut res := CMsgJSreleaseCallback{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_function_handle = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.function_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgjsreleasecallback() CMsgJSreleaseCallback { +return CMsgJSreleaseCallback{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgjsreleasecallback(o CMsgJSreleaseCallback, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgjsreleasecallback(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgJSreleaseCallback) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgjsreleasecallback_unpack(v)? +return i, unpacked +} +pub struct CMsgJSraiseException { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +exception string +has_exception bool +} +pub fn (o &CMsgJSraiseException) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_exception { +res << vproto.pack_string_field(o.exception, 2) +} + +return res +} + +pub fn cmsgjsraiseexception_unpack(buf []byte) ?CMsgJSraiseException { +mut res := CMsgJSraiseException{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_exception = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.exception = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgjsraiseexception() CMsgJSraiseException { +return CMsgJSraiseException{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgjsraiseexception(o CMsgJSraiseException, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgjsraiseexception(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgJSraiseException) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgjsraiseexception_unpack(v)? +return i, unpacked +} +pub struct CMsgLoadLocalization { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +localization_path string +has_localization_path bool +language string +has_language bool +} +pub fn (o &CMsgLoadLocalization) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_localization_path { +res << vproto.pack_string_field(o.localization_path, 2) +} + +if o.has_language { +res << vproto.pack_string_field(o.language, 3) +} + +return res +} + +pub fn cmsgloadlocalization_unpack(buf []byte) ?CMsgLoadLocalization { +mut res := CMsgLoadLocalization{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_localization_path = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.localization_path = v +i = ii +} + +3 { +res.has_language = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgloadlocalization() CMsgLoadLocalization { +return CMsgLoadLocalization{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgloadlocalization(o CMsgLoadLocalization, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgloadlocalization(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgLoadLocalization) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgloadlocalization_unpack(v)? +return i, unpacked +} +pub struct CMsgJumpListLink { +mut: +unknown_fields []vproto.UnknownField +pub mut: +display_name string +has_display_name bool +url_link string +has_url_link bool +icon_path string +has_icon_path bool +} +pub fn (o &CMsgJumpListLink) pack() []byte { +mut res := []byte{} +if o.has_display_name { +res << vproto.pack_string_field(o.display_name, 1) +} + +if o.has_url_link { +res << vproto.pack_string_field(o.url_link, 2) +} + +if o.has_icon_path { +res << vproto.pack_string_field(o.icon_path, 3) +} + +return res +} + +pub fn cmsgjumplistlink_unpack(buf []byte) ?CMsgJumpListLink { +mut res := CMsgJumpListLink{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_display_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.display_name = v +i = ii +} + +2 { +res.has_url_link = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url_link = v +i = ii +} + +3 { +res.has_icon_path = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.icon_path = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgjumplistlink() CMsgJumpListLink { +return CMsgJumpListLink{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgjumplistlink(o CMsgJumpListLink, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgjumplistlink(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgJumpListLink) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgjumplistlink_unpack(v)? +return i, unpacked +} +pub struct CMsgJumpListMRuapp { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +display_name string +has_display_name bool +url_link string +has_url_link bool +icon_path string +has_icon_path bool +} +pub fn (o &CMsgJumpListMRuapp) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_display_name { +res << vproto.pack_string_field(o.display_name, 2) +} + +if o.has_url_link { +res << vproto.pack_string_field(o.url_link, 3) +} + +if o.has_icon_path { +res << vproto.pack_string_field(o.icon_path, 4) +} + +return res +} + +pub fn cmsgjumplistmruapp_unpack(buf []byte) ?CMsgJumpListMRuapp { +mut res := CMsgJumpListMRuapp{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_display_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.display_name = v +i = ii +} + +3 { +res.has_url_link = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url_link = v +i = ii +} + +4 { +res.has_icon_path = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.icon_path = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgjumplistmruapp() CMsgJumpListMRuapp { +return CMsgJumpListMRuapp{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgjumplistmruapp(o CMsgJumpListMRuapp, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgjumplistmruapp(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgJumpListMRuapp) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgjumplistmruapp_unpack(v)? +return i, unpacked +} +pub struct CMsgSetJumpList { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_path string +has_steam_path bool +mru_title string +has_mru_title bool +apps []CMsgJumpListMRuapp +links []CMsgJumpListLink +} +pub fn (o &CMsgSetJumpList) pack() []byte { +mut res := []byte{} +if o.has_steam_path { +res << vproto.pack_string_field(o.steam_path, 1) +} + +if o.has_mru_title { +res << vproto.pack_string_field(o.mru_title, 2) +} + +// [packed=false] +for _, x in o.apps { +res << zzz_vproto_internal_pack_cmsgjumplistmruapp(x, 3) +} + +// [packed=false] +for _, x in o.links { +res << zzz_vproto_internal_pack_cmsgjumplistlink(x, 4) +} + +return res +} + +pub fn cmsgsetjumplist_unpack(buf []byte) ?CMsgSetJumpList { +mut res := CMsgSetJumpList{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_path = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.steam_path = v +i = ii +} + +2 { +res.has_mru_title = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.mru_title = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgjumplistmruapp(cur_buf, tag_wiretype.wire_type)? +res.apps << v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgjumplistlink(cur_buf, tag_wiretype.wire_type)? +res.links << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsetjumplist() CMsgSetJumpList { +return CMsgSetJumpList{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsetjumplist(o CMsgSetJumpList, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsetjumplist(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSetJumpList) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsetjumplist_unpack(v)? +return i, unpacked +} +pub struct CMsgSetGameOverlayTargetPIds { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +target_pid []u32 +} +pub fn (o &CMsgSetGameOverlayTargetPIds) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +// [packed=false] +for _, x in o.target_pid { +res << vproto.pack_uint32_field(x, 2) +} + +return res +} + +pub fn cmsgsetgameoverlaytargetpids_unpack(buf []byte) ?CMsgSetGameOverlayTargetPIds { +mut res := CMsgSetGameOverlayTargetPIds{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.target_pid << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsetgameoverlaytargetpids() CMsgSetGameOverlayTargetPIds { +return CMsgSetGameOverlayTargetPIds{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsetgameoverlaytargetpids(o CMsgSetGameOverlayTargetPIds, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsetgameoverlaytargetpids(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSetGameOverlayTargetPIds) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsetgameoverlaytargetpids_unpack(v)? +return i, unpacked +} +pub struct CMsgGameOverlayTargetTextureID { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +target_pid u32 +has_target_pid bool +texture_handle u32 +has_texture_handle bool +} +pub fn (o &CMsgGameOverlayTargetTextureID) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_target_pid { +res << vproto.pack_uint32_field(o.target_pid, 2) +} + +if o.has_texture_handle { +res << vproto.pack_uint32_field(o.texture_handle, 3) +} + +return res +} + +pub fn cmsggameoverlaytargettextureid_unpack(buf []byte) ?CMsgGameOverlayTargetTextureID { +mut res := CMsgGameOverlayTargetTextureID{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_target_pid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.target_pid = v +i = ii +} + +3 { +res.has_texture_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.texture_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggameoverlaytargettextureid() CMsgGameOverlayTargetTextureID { +return CMsgGameOverlayTargetTextureID{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggameoverlaytargettextureid(o CMsgGameOverlayTargetTextureID, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggameoverlaytargettextureid(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGameOverlayTargetTextureID) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggameoverlaytargettextureid_unpack(v)? +return i, unpacked +} +pub struct CMsgDraggableRegionsChangedDraggableRects { +mut: +unknown_fields []vproto.UnknownField +pub mut: +x int +has_x bool +y int +has_y bool +width int +has_width bool +height int +has_height bool +draggable bool +has_draggable bool +} +pub fn (o &CMsgDraggableRegionsChangedDraggableRects) pack() []byte { +mut res := []byte{} +if o.has_x { +res << vproto.pack_int32_field(o.x, 1) +} + +if o.has_y { +res << vproto.pack_int32_field(o.y, 2) +} + +if o.has_width { +res << vproto.pack_int32_field(o.width, 3) +} + +if o.has_height { +res << vproto.pack_int32_field(o.height, 4) +} + +if o.has_draggable { +res << vproto.pack_bool_field(o.draggable, 5) +} + +return res +} + +pub fn cmsgdraggableregionschangeddraggablerects_unpack(buf []byte) ?CMsgDraggableRegionsChangedDraggableRects { +mut res := CMsgDraggableRegionsChangedDraggableRects{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_x = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.x = v +i = ii +} + +2 { +res.has_y = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.y = v +i = ii +} + +3 { +res.has_width = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.width = v +i = ii +} + +4 { +res.has_height = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.height = v +i = ii +} + +5 { +res.has_draggable = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.draggable = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgdraggableregionschangeddraggablerects() CMsgDraggableRegionsChangedDraggableRects { +return CMsgDraggableRegionsChangedDraggableRects{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgdraggableregionschangeddraggablerects(o CMsgDraggableRegionsChangedDraggableRects, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgdraggableregionschangeddraggablerects(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgDraggableRegionsChangedDraggableRects) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgdraggableregionschangeddraggablerects_unpack(v)? +return i, unpacked +} +pub struct CMsgDraggableRegionsChanged { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +rects []CMsgDraggableRegionsChangedDraggableRects +} +pub fn (o &CMsgDraggableRegionsChanged) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +// [packed=false] +for _, x in o.rects { +res << zzz_vproto_internal_pack_cmsgdraggableregionschangeddraggablerects(x, 2) +} + +return res +} + +pub fn cmsgdraggableregionschanged_unpack(buf []byte) ?CMsgDraggableRegionsChanged { +mut res := CMsgDraggableRegionsChanged{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgdraggableregionschangeddraggablerects(cur_buf, tag_wiretype.wire_type)? +res.rects << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgdraggableregionschanged() CMsgDraggableRegionsChanged { +return CMsgDraggableRegionsChanged{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgdraggableregionschanged(o CMsgDraggableRegionsChanged, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgdraggableregionschanged(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgDraggableRegionsChanged) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgdraggableregionschanged_unpack(v)? +return i, unpacked +} +pub struct CMsgResizeGripChanged { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +width int +has_width bool +height int +has_height bool +} +pub fn (o &CMsgResizeGripChanged) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_width { +res << vproto.pack_int32_field(o.width, 2) +} + +if o.has_height { +res << vproto.pack_int32_field(o.height, 3) +} + +return res +} + +pub fn cmsgresizegripchanged_unpack(buf []byte) ?CMsgResizeGripChanged { +mut res := CMsgResizeGripChanged{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_width = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.width = v +i = ii +} + +3 { +res.has_height = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.height = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgresizegripchanged() CMsgResizeGripChanged { +return CMsgResizeGripChanged{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgresizegripchanged(o CMsgResizeGripChanged, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgresizegripchanged(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgResizeGripChanged) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgresizegripchanged_unpack(v)? +return i, unpacked +} +pub struct CMsgSetWindowPosition { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +x int +has_x bool +y int +has_y bool +width int +has_width bool +height int +has_height bool +min_width int +has_min_width bool +min_height int +has_min_height bool +} +pub fn (o &CMsgSetWindowPosition) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_x { +res << vproto.pack_int32_field(o.x, 2) +} + +if o.has_y { +res << vproto.pack_int32_field(o.y, 3) +} + +if o.has_width { +res << vproto.pack_int32_field(o.width, 4) +} + +if o.has_height { +res << vproto.pack_int32_field(o.height, 5) +} + +if o.has_min_width { +res << vproto.pack_int32_field(o.min_width, 6) +} + +if o.has_min_height { +res << vproto.pack_int32_field(o.min_height, 7) +} + +return res +} + +pub fn cmsgsetwindowposition_unpack(buf []byte) ?CMsgSetWindowPosition { +mut res := CMsgSetWindowPosition{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_x = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.x = v +i = ii +} + +3 { +res.has_y = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.y = v +i = ii +} + +4 { +res.has_width = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.width = v +i = ii +} + +5 { +res.has_height = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.height = v +i = ii +} + +6 { +res.has_min_width = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.min_width = v +i = ii +} + +7 { +res.has_min_height = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.min_height = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsetwindowposition() CMsgSetWindowPosition { +return CMsgSetWindowPosition{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsetwindowposition(o CMsgSetWindowPosition, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsetwindowposition(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSetWindowPosition) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsetwindowposition_unpack(v)? +return i, unpacked +} +pub struct CMsgShowWindow { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgShowWindow) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgshowwindow_unpack(buf []byte) ?CMsgShowWindow { +mut res := CMsgShowWindow{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgshowwindow() CMsgShowWindow { +return CMsgShowWindow{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgshowwindow(o CMsgShowWindow, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgshowwindow(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgShowWindow) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgshowwindow_unpack(v)? +return i, unpacked +} +pub struct CMsgHideWindow { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgHideWindow) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsghidewindow_unpack(buf []byte) ?CMsgHideWindow { +mut res := CMsgHideWindow{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsghidewindow() CMsgHideWindow { +return CMsgHideWindow{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsghidewindow(o CMsgHideWindow, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsghidewindow(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgHideWindow) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsghidewindow_unpack(v)? +return i, unpacked +} +pub struct CMsgBringWindowToFront { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgBringWindowToFront) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgbringwindowtofront_unpack(buf []byte) ?CMsgBringWindowToFront { +mut res := CMsgBringWindowToFront{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgbringwindowtofront() CMsgBringWindowToFront { +return CMsgBringWindowToFront{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgbringwindowtofront(o CMsgBringWindowToFront, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgbringwindowtofront(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgBringWindowToFront) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgbringwindowtofront_unpack(v)? +return i, unpacked +} +pub struct CMsgSetForegroundWindow { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgSetForegroundWindow) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgsetforegroundwindow_unpack(buf []byte) ?CMsgSetForegroundWindow { +mut res := CMsgSetForegroundWindow{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsetforegroundwindow() CMsgSetForegroundWindow { +return CMsgSetForegroundWindow{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsetforegroundwindow(o CMsgSetForegroundWindow, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsetforegroundwindow(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSetForegroundWindow) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsetforegroundwindow_unpack(v)? +return i, unpacked +} +pub struct CMsgMaximizeRestoreWindow { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgMaximizeRestoreWindow) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgmaximizerestorewindow_unpack(buf []byte) ?CMsgMaximizeRestoreWindow { +mut res := CMsgMaximizeRestoreWindow{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgmaximizerestorewindow() CMsgMaximizeRestoreWindow { +return CMsgMaximizeRestoreWindow{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgmaximizerestorewindow(o CMsgMaximizeRestoreWindow, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgmaximizerestorewindow(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgMaximizeRestoreWindow) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgmaximizerestorewindow_unpack(v)? +return i, unpacked +} +pub struct CMsgMinimizeWindow { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgMinimizeWindow) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgminimizewindow_unpack(buf []byte) ?CMsgMinimizeWindow { +mut res := CMsgMinimizeWindow{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgminimizewindow() CMsgMinimizeWindow { +return CMsgMinimizeWindow{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgminimizewindow(o CMsgMinimizeWindow, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgminimizewindow(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgMinimizeWindow) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgminimizewindow_unpack(v)? +return i, unpacked +} +pub struct CMsgShowBrowserContextMenu { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgShowBrowserContextMenu) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgshowbrowsercontextmenu_unpack(buf []byte) ?CMsgShowBrowserContextMenu { +mut res := CMsgShowBrowserContextMenu{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgshowbrowsercontextmenu() CMsgShowBrowserContextMenu { +return CMsgShowBrowserContextMenu{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgshowbrowsercontextmenu(o CMsgShowBrowserContextMenu, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgshowbrowsercontextmenu(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgShowBrowserContextMenu) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgshowbrowsercontextmenu_unpack(v)? +return i, unpacked +} +pub struct CMsgImeSetComposition { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +text string +has_text bool +} +pub fn (o &CMsgImeSetComposition) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_text { +res << vproto.pack_string_field(o.text, 2) +} + +return res +} + +pub fn cmsgimesetcomposition_unpack(buf []byte) ?CMsgImeSetComposition { +mut res := CMsgImeSetComposition{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_text = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.text = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgimesetcomposition() CMsgImeSetComposition { +return CMsgImeSetComposition{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgimesetcomposition(o CMsgImeSetComposition, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgimesetcomposition(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgImeSetComposition) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgimesetcomposition_unpack(v)? +return i, unpacked +} +pub struct CMsgImeCommitText { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +text string +has_text bool +} +pub fn (o &CMsgImeCommitText) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_text { +res << vproto.pack_string_field(o.text, 2) +} + +return res +} + +pub fn cmsgimecommittext_unpack(buf []byte) ?CMsgImeCommitText { +mut res := CMsgImeCommitText{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_text = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.text = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgimecommittext() CMsgImeCommitText { +return CMsgImeCommitText{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgimecommittext(o CMsgImeCommitText, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgimecommittext(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgImeCommitText) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgimecommittext_unpack(v)? +return i, unpacked +} +pub struct CMsgImeCancelComposition { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +} +pub fn (o &CMsgImeCancelComposition) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +return res +} + +pub fn cmsgimecancelcomposition_unpack(buf []byte) ?CMsgImeCancelComposition { +mut res := CMsgImeCancelComposition{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgimecancelcomposition() CMsgImeCancelComposition { +return CMsgImeCancelComposition{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgimecancelcomposition(o CMsgImeCancelComposition, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgimecancelcomposition(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgImeCancelComposition) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgimecancelcomposition_unpack(v)? +return i, unpacked +} +pub struct CMsgImeCompositionRangeChanged { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +x u32 +has_x bool +y u32 +has_y bool +} +pub fn (o &CMsgImeCompositionRangeChanged) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_x { +res << vproto.pack_uint32_field(o.x, 2) +} + +if o.has_y { +res << vproto.pack_uint32_field(o.y, 3) +} + +return res +} + +pub fn cmsgimecompositionrangechanged_unpack(buf []byte) ?CMsgImeCompositionRangeChanged { +mut res := CMsgImeCompositionRangeChanged{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_x = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.x = v +i = ii +} + +3 { +res.has_y = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.y = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgimecompositionrangechanged() CMsgImeCompositionRangeChanged { +return CMsgImeCompositionRangeChanged{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgimecompositionrangechanged(o CMsgImeCompositionRangeChanged, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgimecompositionrangechanged(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgImeCompositionRangeChanged) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgimecompositionrangechanged_unpack(v)? +return i, unpacked +} +pub struct CMsgInspectElement { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +x u32 +has_x bool +y u32 +has_y bool +} +pub fn (o &CMsgInspectElement) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_x { +res << vproto.pack_uint32_field(o.x, 2) +} + +if o.has_y { +res << vproto.pack_uint32_field(o.y, 3) +} + +return res +} + +pub fn cmsginspectelement_unpack(buf []byte) ?CMsgInspectElement { +mut res := CMsgInspectElement{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_x = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.x = v +i = ii +} + +3 { +res.has_y = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.y = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsginspectelement() CMsgInspectElement { +return CMsgInspectElement{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsginspectelement(o CMsgInspectElement, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsginspectelement(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgInspectElement) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsginspectelement_unpack(v)? +return i, unpacked +} +pub struct CMsgDisableF5 { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +disable bool +has_disable bool +} +pub fn (o &CMsgDisableF5) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_disable { +res << vproto.pack_bool_field(o.disable, 2) +} + +return res +} + +pub fn cmsgdisablef5_unpack(buf []byte) ?CMsgDisableF5 { +mut res := CMsgDisableF5{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_disable = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.disable = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgdisablef5() CMsgDisableF5 { +return CMsgDisableF5{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgdisablef5(o CMsgDisableF5, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgdisablef5(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgDisableF5) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgdisablef5_unpack(v)? +return i, unpacked +} +pub struct CMsgStartDownload { +mut: +unknown_fields []vproto.UnknownField +pub mut: +browser_handle u32 +has_browser_handle bool +url string +has_url bool +} +pub fn (o &CMsgStartDownload) pack() []byte { +mut res := []byte{} +if o.has_browser_handle { +res << vproto.pack_uint32_field(o.browser_handle, 1) +} + +if o.has_url { +res << vproto.pack_string_field(o.url, 2) +} + +return res +} + +pub fn cmsgstartdownload_unpack(buf []byte) ?CMsgStartDownload { +mut res := CMsgStartDownload{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_browser_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.browser_handle = v +i = ii +} + +2 { +res.has_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgstartdownload() CMsgStartDownload { +return CMsgStartDownload{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgstartdownload(o CMsgStartDownload, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgstartdownload(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgStartDownload) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgstartdownload_unpack(v)? +return i, unpacked +} diff --git a/proto/steamdatagram_messages_auth_pb.v b/proto/steamdatagram_messages_auth_pb.v new file mode 100644 index 0000000..280354c --- /dev/null +++ b/proto/steamdatagram_messages_auth_pb.v @@ -0,0 +1,829 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CMsgSteamDatagramRelayAuthTicketExtraField { +mut: +unknown_fields []vproto.UnknownField +pub mut: +name string +has_name bool +string_value string +has_string_value bool +int64_value i64 +has_int64_value bool +fixed64_value u64 +has_fixed64_value bool +} +pub fn (o &CMsgSteamDatagramRelayAuthTicketExtraField) pack() []byte { +mut res := []byte{} +if o.has_name { +res << vproto.pack_string_field(o.name, 1) +} + +if o.has_string_value { +res << vproto.pack_string_field(o.string_value, 2) +} + +if o.has_int64_value { +res << vproto.pack_sint64_field(o.int64_value, 3) +} + +if o.has_fixed64_value { +res << vproto.pack_64bit_field(o.fixed64_value, 5) +} + +return res +} + +pub fn cmsgsteamdatagramrelayauthticketextrafield_unpack(buf []byte) ?CMsgSteamDatagramRelayAuthTicketExtraField { +mut res := CMsgSteamDatagramRelayAuthTicketExtraField{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +2 { +res.has_string_value = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.string_value = v +i = ii +} + +3 { +res.has_int64_value = true +ii, v := vproto.unpack_sint64_field(cur_buf, tag_wiretype.wire_type)? +res.int64_value = v +i = ii +} + +5 { +res.has_fixed64_value = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.fixed64_value = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramrelayauthticketextrafield() CMsgSteamDatagramRelayAuthTicketExtraField { +return CMsgSteamDatagramRelayAuthTicketExtraField{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramrelayauthticketextrafield(o CMsgSteamDatagramRelayAuthTicketExtraField, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramrelayauthticketextrafield(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramRelayAuthTicketExtraField) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramrelayauthticketextrafield_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramRelayAuthTicket { +mut: +unknown_fields []vproto.UnknownField +pub mut: +time_expiry u32 +has_time_expiry bool +authorized_client_identity_string string +has_authorized_client_identity_string bool +gameserver_identity_string string +has_gameserver_identity_string bool +authorized_public_ip u32 +has_authorized_public_ip bool +gameserver_address []byte +has_gameserver_address bool +app_id u32 +has_app_id bool +virtual_port u32 +has_virtual_port bool +extra_fields []CMsgSteamDatagramRelayAuthTicketExtraField +legacy_authorized_steam_id u64 +has_legacy_authorized_steam_id bool +legacy_gameserver_steam_id u64 +has_legacy_gameserver_steam_id bool +legacy_gameserver_net_id u64 +has_legacy_gameserver_net_id bool +legacy_gameserver_pop_id u32 +has_legacy_gameserver_pop_id bool +legacy_authorized_client_identity_binary []byte +has_legacy_authorized_client_identity_binary bool +legacy_gameserver_identity_binary []byte +has_legacy_gameserver_identity_binary bool +} +pub fn (o &CMsgSteamDatagramRelayAuthTicket) pack() []byte { +mut res := []byte{} +if o.has_time_expiry { +res << vproto.pack_32bit_field(o.time_expiry, 1) +} + +if o.has_authorized_client_identity_string { +res << vproto.pack_string_field(o.authorized_client_identity_string, 14) +} + +if o.has_gameserver_identity_string { +res << vproto.pack_string_field(o.gameserver_identity_string, 15) +} + +if o.has_authorized_public_ip { +res << vproto.pack_32bit_field(o.authorized_public_ip, 3) +} + +if o.has_gameserver_address { +res << vproto.pack_bytes_field(o.gameserver_address, 11) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 7) +} + +if o.has_virtual_port { +res << vproto.pack_uint32_field(o.virtual_port, 10) +} + +// [packed=false] +for _, x in o.extra_fields { +res << zzz_vproto_internal_pack_cmsgsteamdatagramrelayauthticketextrafield(x, 8) +} + +if o.has_legacy_authorized_steam_id { +res << vproto.pack_64bit_field(o.legacy_authorized_steam_id, 2) +} + +if o.has_legacy_gameserver_steam_id { +res << vproto.pack_64bit_field(o.legacy_gameserver_steam_id, 4) +} + +if o.has_legacy_gameserver_net_id { +res << vproto.pack_64bit_field(o.legacy_gameserver_net_id, 5) +} + +if o.has_legacy_gameserver_pop_id { +res << vproto.pack_32bit_field(o.legacy_gameserver_pop_id, 9) +} + +if o.has_legacy_authorized_client_identity_binary { +res << vproto.pack_bytes_field(o.legacy_authorized_client_identity_binary, 12) +} + +if o.has_legacy_gameserver_identity_binary { +res << vproto.pack_bytes_field(o.legacy_gameserver_identity_binary, 13) +} + +return res +} + +pub fn cmsgsteamdatagramrelayauthticket_unpack(buf []byte) ?CMsgSteamDatagramRelayAuthTicket { +mut res := CMsgSteamDatagramRelayAuthTicket{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_time_expiry = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.time_expiry = v +i = ii +} + +14 { +res.has_authorized_client_identity_string = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.authorized_client_identity_string = v +i = ii +} + +15 { +res.has_gameserver_identity_string = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.gameserver_identity_string = v +i = ii +} + +3 { +res.has_authorized_public_ip = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.authorized_public_ip = v +i = ii +} + +11 { +res.has_gameserver_address = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.gameserver_address = v +i = ii +} + +7 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +10 { +res.has_virtual_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.virtual_port = v +i = ii +} + +8 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramrelayauthticketextrafield(cur_buf, tag_wiretype.wire_type)? +res.extra_fields << v +i = ii +} + +2 { +res.has_legacy_authorized_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.legacy_authorized_steam_id = v +i = ii +} + +4 { +res.has_legacy_gameserver_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.legacy_gameserver_steam_id = v +i = ii +} + +5 { +res.has_legacy_gameserver_net_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.legacy_gameserver_net_id = v +i = ii +} + +9 { +res.has_legacy_gameserver_pop_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.legacy_gameserver_pop_id = v +i = ii +} + +12 { +res.has_legacy_authorized_client_identity_binary = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.legacy_authorized_client_identity_binary = v +i = ii +} + +13 { +res.has_legacy_gameserver_identity_binary = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.legacy_gameserver_identity_binary = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramrelayauthticket() CMsgSteamDatagramRelayAuthTicket { +return CMsgSteamDatagramRelayAuthTicket{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramrelayauthticket(o CMsgSteamDatagramRelayAuthTicket, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramrelayauthticket(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramRelayAuthTicket) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramrelayauthticket_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramSignedRelayAuthTicket { +mut: +unknown_fields []vproto.UnknownField +pub mut: +reserved_do_not_use u64 +has_reserved_do_not_use bool +key_id u64 +has_key_id bool +ticket []byte +has_ticket bool +signature []byte +has_signature bool +} +pub fn (o &CMsgSteamDatagramSignedRelayAuthTicket) pack() []byte { +mut res := []byte{} +if o.has_reserved_do_not_use { +res << vproto.pack_64bit_field(o.reserved_do_not_use, 1) +} + +if o.has_key_id { +res << vproto.pack_64bit_field(o.key_id, 2) +} + +if o.has_ticket { +res << vproto.pack_bytes_field(o.ticket, 3) +} + +if o.has_signature { +res << vproto.pack_bytes_field(o.signature, 4) +} + +return res +} + +pub fn cmsgsteamdatagramsignedrelayauthticket_unpack(buf []byte) ?CMsgSteamDatagramSignedRelayAuthTicket { +mut res := CMsgSteamDatagramSignedRelayAuthTicket{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_reserved_do_not_use = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.reserved_do_not_use = v +i = ii +} + +2 { +res.has_key_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.key_id = v +i = ii +} + +3 { +res.has_ticket = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.ticket = v +i = ii +} + +4 { +res.has_signature = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.signature = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramsignedrelayauthticket() CMsgSteamDatagramSignedRelayAuthTicket { +return CMsgSteamDatagramSignedRelayAuthTicket{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramsignedrelayauthticket(o CMsgSteamDatagramSignedRelayAuthTicket, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramsignedrelayauthticket(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramSignedRelayAuthTicket) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramsignedrelayauthticket_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramCachedCredentialsForApp { +mut: +unknown_fields []vproto.UnknownField +pub mut: +private_key []byte +has_private_key bool +cert []byte +has_cert bool +relay_tickets [][]byte +} +pub fn (o &CMsgSteamDatagramCachedCredentialsForApp) pack() []byte { +mut res := []byte{} +if o.has_private_key { +res << vproto.pack_bytes_field(o.private_key, 1) +} + +if o.has_cert { +res << vproto.pack_bytes_field(o.cert, 2) +} + +// [packed=false] +for _, x in o.relay_tickets { +res << vproto.pack_bytes_field(x, 3) +} + +return res +} + +pub fn cmsgsteamdatagramcachedcredentialsforapp_unpack(buf []byte) ?CMsgSteamDatagramCachedCredentialsForApp { +mut res := CMsgSteamDatagramCachedCredentialsForApp{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_private_key = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.private_key = v +i = ii +} + +2 { +res.has_cert = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.cert = v +i = ii +} + +3 { +// [packed=false] +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.relay_tickets << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramcachedcredentialsforapp() CMsgSteamDatagramCachedCredentialsForApp { +return CMsgSteamDatagramCachedCredentialsForApp{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramcachedcredentialsforapp(o CMsgSteamDatagramCachedCredentialsForApp, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramcachedcredentialsforapp(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramCachedCredentialsForApp) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramcachedcredentialsforapp_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramGameCoordinatorServerLogin { +mut: +unknown_fields []vproto.UnknownField +pub mut: +time_generated u32 +has_time_generated bool +appid u32 +has_appid bool +routing []byte +has_routing bool +appdata []byte +has_appdata bool +legacy_identity_binary []byte +has_legacy_identity_binary bool +identity_string string +has_identity_string bool +dummy_steam_id u64 +has_dummy_steam_id bool +} +pub fn (o &CMsgSteamDatagramGameCoordinatorServerLogin) pack() []byte { +mut res := []byte{} +if o.has_time_generated { +res << vproto.pack_uint32_field(o.time_generated, 1) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 2) +} + +if o.has_routing { +res << vproto.pack_bytes_field(o.routing, 3) +} + +if o.has_appdata { +res << vproto.pack_bytes_field(o.appdata, 4) +} + +if o.has_legacy_identity_binary { +res << vproto.pack_bytes_field(o.legacy_identity_binary, 5) +} + +if o.has_identity_string { +res << vproto.pack_string_field(o.identity_string, 6) +} + +if o.has_dummy_steam_id { +res << vproto.pack_64bit_field(o.dummy_steam_id, 99) +} + +return res +} + +pub fn cmsgsteamdatagramgamecoordinatorserverlogin_unpack(buf []byte) ?CMsgSteamDatagramGameCoordinatorServerLogin { +mut res := CMsgSteamDatagramGameCoordinatorServerLogin{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_time_generated = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_generated = v +i = ii +} + +2 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +3 { +res.has_routing = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.routing = v +i = ii +} + +4 { +res.has_appdata = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.appdata = v +i = ii +} + +5 { +res.has_legacy_identity_binary = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.legacy_identity_binary = v +i = ii +} + +6 { +res.has_identity_string = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.identity_string = v +i = ii +} + +99 { +res.has_dummy_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.dummy_steam_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramgamecoordinatorserverlogin() CMsgSteamDatagramGameCoordinatorServerLogin { +return CMsgSteamDatagramGameCoordinatorServerLogin{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramgamecoordinatorserverlogin(o CMsgSteamDatagramGameCoordinatorServerLogin, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramgamecoordinatorserverlogin(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramGameCoordinatorServerLogin) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramgamecoordinatorserverlogin_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramSignedGameCoordinatorServerLogin { +mut: +unknown_fields []vproto.UnknownField +pub mut: +cert CMsgSteamDatagramCertificateSigned +has_cert bool +login []byte +has_login bool +signature []byte +has_signature bool +} +pub fn (o &CMsgSteamDatagramSignedGameCoordinatorServerLogin) pack() []byte { +mut res := []byte{} +if o.has_cert { +res << zzz_vproto_internal_pack_cmsgsteamdatagramcertificatesigned(o.cert, 1) +} + +if o.has_login { +res << vproto.pack_bytes_field(o.login, 2) +} + +if o.has_signature { +res << vproto.pack_bytes_field(o.signature, 3) +} + +return res +} + +pub fn cmsgsteamdatagramsignedgamecoordinatorserverlogin_unpack(buf []byte) ?CMsgSteamDatagramSignedGameCoordinatorServerLogin { +mut res := CMsgSteamDatagramSignedGameCoordinatorServerLogin{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_cert = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramcertificatesigned(cur_buf, tag_wiretype.wire_type)? +res.cert = v +i = ii +} + +2 { +res.has_login = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.login = v +i = ii +} + +3 { +res.has_signature = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.signature = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramsignedgamecoordinatorserverlogin() CMsgSteamDatagramSignedGameCoordinatorServerLogin { +return CMsgSteamDatagramSignedGameCoordinatorServerLogin{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramsignedgamecoordinatorserverlogin(o CMsgSteamDatagramSignedGameCoordinatorServerLogin, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramsignedgamecoordinatorserverlogin(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramSignedGameCoordinatorServerLogin) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramsignedgamecoordinatorserverlogin_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramHostedServerAddressPlaintext { +mut: +unknown_fields []vproto.UnknownField +pub mut: +ipv4 u32 +has_ipv4 bool +ipv6 []byte +has_ipv6 bool +port u32 +has_port bool +routing_secret u64 +has_routing_secret bool +} +pub fn (o &CMsgSteamDatagramHostedServerAddressPlaintext) pack() []byte { +mut res := []byte{} +if o.has_ipv4 { +res << vproto.pack_32bit_field(o.ipv4, 1) +} + +if o.has_ipv6 { +res << vproto.pack_bytes_field(o.ipv6, 2) +} + +if o.has_port { +res << vproto.pack_uint32_field(o.port, 3) +} + +if o.has_routing_secret { +res << vproto.pack_64bit_field(o.routing_secret, 4) +} + +return res +} + +pub fn cmsgsteamdatagramhostedserveraddressplaintext_unpack(buf []byte) ?CMsgSteamDatagramHostedServerAddressPlaintext { +mut res := CMsgSteamDatagramHostedServerAddressPlaintext{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_ipv4 = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.ipv4 = v +i = ii +} + +2 { +res.has_ipv6 = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.ipv6 = v +i = ii +} + +3 { +res.has_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.port = v +i = ii +} + +4 { +res.has_routing_secret = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.routing_secret = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramhostedserveraddressplaintext() CMsgSteamDatagramHostedServerAddressPlaintext { +return CMsgSteamDatagramHostedServerAddressPlaintext{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramhostedserveraddressplaintext(o CMsgSteamDatagramHostedServerAddressPlaintext, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramhostedserveraddressplaintext(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramHostedServerAddressPlaintext) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramhostedserveraddressplaintext_unpack(v)? +return i, unpacked +} diff --git a/proto/steamdatagram_messages_sdr_pb.v b/proto/steamdatagram_messages_sdr_pb.v new file mode 100644 index 0000000..ec6e3c9 --- /dev/null +++ b/proto/steamdatagram_messages_sdr_pb.v @@ -0,0 +1,5752 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +[_allow_multiple_values] +enum ESteamDatagramMsgID { +k_esteamdatagrammsg_invalid = 0 +k_esteamdatagrammsg_routerpingrequest = 1 +k_esteamdatagrammsg_routerpingreply = 2 +k_esteamdatagrammsg_gameserverpingrequest = 3 +k_esteamdatagrammsg_legacygameserverpingreply = 4 +k_esteamdatagrammsg_gameserversessionrequest = 5 +k_esteamdatagrammsg_gameserversessionestablished = 6 +k_esteamdatagrammsg_nosession = 7 +k_esteamdatagrammsg_diagnostic = 8 +k_esteamdatagrammsg_dataclienttorouter = 9 +k_esteamdatagrammsg_dataroutertoserver = 10 +k_esteamdatagrammsg_dataservertorouter = 11 +k_esteamdatagrammsg_dataroutertoclient = 12 +k_esteamdatagrammsg_stats = 13 +k_esteamdatagrammsg_clientpingsamplerequest = 14 +k_esteamdatagrammsg_clientpingsamplereply = 15 +k_esteamdatagrammsg_clienttorouterswitchedprimary = 16 +k_esteamdatagrammsg_relayhealth = 17 +k_esteamdatagrammsg_connectrequest = 18 +k_esteamdatagrammsg_connectok = 19 +k_esteamdatagrammsg_connectionclosed = 20 +k_esteamdatagrammsg_noconnection = 21 +k_esteamdatagrammsg_relaytorelaypingrequest = 22 +k_esteamdatagrammsg_relaytorelaypingreply = 23 +k_esteamdatagrammsg_p2psessionrequest = 24 +k_esteamdatagrammsg_p2psessionestablished = 25 +k_esteamdatagrammsg_p2pstatsclient = 26 +k_esteamdatagrammsg_p2pstatsrelay = 27 +k_esteamdatagrammsg_p2pbadroute = 28 +k_esteamdatagrammsg_gameserverpingreply = 29 +k_esteamdatagrammsg_gameserverregistration = 30 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_esteamdatagrammsgid(e ESteamDatagramMsgID, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_esteamdatagrammsgid(buf []byte, tag_wiretype vproto.WireType) ?(int, ESteamDatagramMsgID) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, ESteamDatagramMsgID(v) +} +pub struct CMsgSteamDatagramRouterPingReplyRouteException { +mut: +unknown_fields []vproto.UnknownField +pub mut: +data_center_id u32 +has_data_center_id bool +flags u32 +has_flags bool +penalty u32 +has_penalty bool +} +pub fn (o &CMsgSteamDatagramRouterPingReplyRouteException) pack() []byte { +mut res := []byte{} +if o.has_data_center_id { +res << vproto.pack_32bit_field(o.data_center_id, 1) +} + +if o.has_flags { +res << vproto.pack_uint32_field(o.flags, 2) +} + +if o.has_penalty { +res << vproto.pack_uint32_field(o.penalty, 3) +} + +return res +} + +pub fn cmsgsteamdatagramrouterpingreplyrouteexception_unpack(buf []byte) ?CMsgSteamDatagramRouterPingReplyRouteException { +mut res := CMsgSteamDatagramRouterPingReplyRouteException{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_data_center_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.data_center_id = v +i = ii +} + +2 { +res.has_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.flags = v +i = ii +} + +3 { +res.has_penalty = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.penalty = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramrouterpingreplyrouteexception() CMsgSteamDatagramRouterPingReplyRouteException { +return CMsgSteamDatagramRouterPingReplyRouteException{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramrouterpingreplyrouteexception(o CMsgSteamDatagramRouterPingReplyRouteException, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramrouterpingreplyrouteexception(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramRouterPingReplyRouteException) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramrouterpingreplyrouteexception_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramRouterPingReply { +mut: +unknown_fields []vproto.UnknownField +pub mut: +client_timestamp u32 +has_client_timestamp bool +latency_datacenter_ids []u32 +latency_ping_ms []u32 +your_public_ip u32 +has_your_public_ip bool +server_time u32 +has_server_time bool +challenge u64 +has_challenge bool +seconds_until_shutdown u32 +has_seconds_until_shutdown bool +client_cookie u32 +has_client_cookie bool +scoring_penalty_relay_cluster u32 +has_scoring_penalty_relay_cluster bool +route_exceptions []CMsgSteamDatagramRouterPingReplyRouteException +} +pub fn (o &CMsgSteamDatagramRouterPingReply) pack() []byte { +mut res := []byte{} +if o.has_client_timestamp { +res << vproto.pack_32bit_field(o.client_timestamp, 1) +} + +// [packed=true] +res << vproto.pack_32bit_field_packed(o.latency_datacenter_ids, 2) + +// [packed=true] +res << vproto.pack_uint32_field_packed(o.latency_ping_ms, 3) + +if o.has_your_public_ip { +res << vproto.pack_32bit_field(o.your_public_ip, 4) +} + +if o.has_server_time { +res << vproto.pack_32bit_field(o.server_time, 5) +} + +if o.has_challenge { +res << vproto.pack_64bit_field(o.challenge, 6) +} + +if o.has_seconds_until_shutdown { +res << vproto.pack_uint32_field(o.seconds_until_shutdown, 7) +} + +if o.has_client_cookie { +res << vproto.pack_32bit_field(o.client_cookie, 8) +} + +if o.has_scoring_penalty_relay_cluster { +res << vproto.pack_uint32_field(o.scoring_penalty_relay_cluster, 9) +} + +// [packed=false] +for _, x in o.route_exceptions { +res << zzz_vproto_internal_pack_cmsgsteamdatagramrouterpingreplyrouteexception(x, 10) +} + +return res +} + +pub fn cmsgsteamdatagramrouterpingreply_unpack(buf []byte) ?CMsgSteamDatagramRouterPingReply { +mut res := CMsgSteamDatagramRouterPingReply{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_client_timestamp = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.client_timestamp = v +i = ii +} + +2 { +// [packed=true] +ii, v := vproto.unpack_32bit_field_packed(cur_buf, tag_wiretype.wire_type) ? +res.latency_datacenter_ids << v +i = ii +} + +3 { +// [packed=true] +ii, v := vproto.unpack_uint32_field_packed(cur_buf, tag_wiretype.wire_type) ? +res.latency_ping_ms << v +i = ii +} + +4 { +res.has_your_public_ip = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.your_public_ip = v +i = ii +} + +5 { +res.has_server_time = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.server_time = v +i = ii +} + +6 { +res.has_challenge = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.challenge = v +i = ii +} + +7 { +res.has_seconds_until_shutdown = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_until_shutdown = v +i = ii +} + +8 { +res.has_client_cookie = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.client_cookie = v +i = ii +} + +9 { +res.has_scoring_penalty_relay_cluster = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.scoring_penalty_relay_cluster = v +i = ii +} + +10 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramrouterpingreplyrouteexception(cur_buf, tag_wiretype.wire_type)? +res.route_exceptions << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramrouterpingreply() CMsgSteamDatagramRouterPingReply { +return CMsgSteamDatagramRouterPingReply{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramrouterpingreply(o CMsgSteamDatagramRouterPingReply, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramrouterpingreply(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramRouterPingReply) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramrouterpingreply_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramGameserverPingRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +your_public_ip u32 +has_your_public_ip bool +server_time u32 +has_server_time bool +challenge u64 +has_challenge bool +router_timestamp u32 +has_router_timestamp bool +} +pub fn (o &CMsgSteamDatagramGameserverPingRequest) pack() []byte { +mut res := []byte{} +if o.has_your_public_ip { +res << vproto.pack_32bit_field(o.your_public_ip, 1) +} + +if o.has_server_time { +res << vproto.pack_32bit_field(o.server_time, 2) +} + +if o.has_challenge { +res << vproto.pack_64bit_field(o.challenge, 3) +} + +if o.has_router_timestamp { +res << vproto.pack_32bit_field(o.router_timestamp, 4) +} + +return res +} + +pub fn cmsgsteamdatagramgameserverpingrequest_unpack(buf []byte) ?CMsgSteamDatagramGameserverPingRequest { +mut res := CMsgSteamDatagramGameserverPingRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_your_public_ip = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.your_public_ip = v +i = ii +} + +2 { +res.has_server_time = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.server_time = v +i = ii +} + +3 { +res.has_challenge = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.challenge = v +i = ii +} + +4 { +res.has_router_timestamp = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.router_timestamp = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramgameserverpingrequest() CMsgSteamDatagramGameserverPingRequest { +return CMsgSteamDatagramGameserverPingRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramgameserverpingrequest(o CMsgSteamDatagramGameserverPingRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramgameserverpingrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramGameserverPingRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramgameserverpingrequest_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramLegacyGameserverPingReply { +mut: +unknown_fields []vproto.UnknownField +pub mut: +router_timestamp u32 +has_router_timestamp bool +dummy_pad u64 +has_dummy_pad bool +} +pub fn (o &CMsgSteamDatagramLegacyGameserverPingReply) pack() []byte { +mut res := []byte{} +if o.has_router_timestamp { +res << vproto.pack_32bit_field(o.router_timestamp, 4) +} + +if o.has_dummy_pad { +res << vproto.pack_64bit_field(o.dummy_pad, 99) +} + +return res +} + +pub fn cmsgsteamdatagramlegacygameserverpingreply_unpack(buf []byte) ?CMsgSteamDatagramLegacyGameserverPingReply { +mut res := CMsgSteamDatagramLegacyGameserverPingReply{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +4 { +res.has_router_timestamp = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.router_timestamp = v +i = ii +} + +99 { +res.has_dummy_pad = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.dummy_pad = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramlegacygameserverpingreply() CMsgSteamDatagramLegacyGameserverPingReply { +return CMsgSteamDatagramLegacyGameserverPingReply{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramlegacygameserverpingreply(o CMsgSteamDatagramLegacyGameserverPingReply, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramlegacygameserverpingreply(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramLegacyGameserverPingReply) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramlegacygameserverpingreply_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramGameserverPingReplySignedData { +mut: +unknown_fields []vproto.UnknownField +pub mut: +challenge_time u32 +has_challenge_time bool +challenge u64 +has_challenge bool +router_timestamp u32 +has_router_timestamp bool +data_center_id u32 +has_data_center_id bool +appid u32 +has_appid bool +} +pub fn (o &CMsgSteamDatagramGameserverPingReplySignedData) pack() []byte { +mut res := []byte{} +if o.has_challenge_time { +res << vproto.pack_32bit_field(o.challenge_time, 2) +} + +if o.has_challenge { +res << vproto.pack_64bit_field(o.challenge, 3) +} + +if o.has_router_timestamp { +res << vproto.pack_32bit_field(o.router_timestamp, 4) +} + +if o.has_data_center_id { +res << vproto.pack_32bit_field(o.data_center_id, 5) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 6) +} + +return res +} + +pub fn cmsgsteamdatagramgameserverpingreplysigneddata_unpack(buf []byte) ?CMsgSteamDatagramGameserverPingReplySignedData { +mut res := CMsgSteamDatagramGameserverPingReplySignedData{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +2 { +res.has_challenge_time = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.challenge_time = v +i = ii +} + +3 { +res.has_challenge = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.challenge = v +i = ii +} + +4 { +res.has_router_timestamp = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.router_timestamp = v +i = ii +} + +5 { +res.has_data_center_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.data_center_id = v +i = ii +} + +6 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramgameserverpingreplysigneddata() CMsgSteamDatagramGameserverPingReplySignedData { +return CMsgSteamDatagramGameserverPingReplySignedData{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramgameserverpingreplysigneddata(o CMsgSteamDatagramGameserverPingReplySignedData, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramgameserverpingreplysigneddata(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramGameserverPingReplySignedData) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramgameserverpingreplysigneddata_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramGameserverPingReply { +mut: +unknown_fields []vproto.UnknownField +pub mut: +cert CMsgSteamDatagramCertificateSigned +has_cert bool +signed_data []byte +has_signed_data bool +signature []byte +has_signature bool +} +pub fn (o &CMsgSteamDatagramGameserverPingReply) pack() []byte { +mut res := []byte{} +if o.has_cert { +res << zzz_vproto_internal_pack_cmsgsteamdatagramcertificatesigned(o.cert, 1) +} + +if o.has_signed_data { +res << vproto.pack_bytes_field(o.signed_data, 2) +} + +if o.has_signature { +res << vproto.pack_bytes_field(o.signature, 3) +} + +return res +} + +pub fn cmsgsteamdatagramgameserverpingreply_unpack(buf []byte) ?CMsgSteamDatagramGameserverPingReply { +mut res := CMsgSteamDatagramGameserverPingReply{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_cert = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramcertificatesigned(cur_buf, tag_wiretype.wire_type)? +res.cert = v +i = ii +} + +2 { +res.has_signed_data = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.signed_data = v +i = ii +} + +3 { +res.has_signature = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.signature = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramgameserverpingreply() CMsgSteamDatagramGameserverPingReply { +return CMsgSteamDatagramGameserverPingReply{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramgameserverpingreply(o CMsgSteamDatagramGameserverPingReply, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramgameserverpingreply(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramGameserverPingReply) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramgameserverpingreply_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramNoSessionRelayToClient { +mut: +unknown_fields []vproto.UnknownField +pub mut: +connection_id u32 +has_connection_id bool +your_public_ip u32 +has_your_public_ip bool +server_time u32 +has_server_time bool +challenge u64 +has_challenge bool +seconds_until_shutdown u32 +has_seconds_until_shutdown bool +} +pub fn (o &CMsgSteamDatagramNoSessionRelayToClient) pack() []byte { +mut res := []byte{} +if o.has_connection_id { +res << vproto.pack_32bit_field(o.connection_id, 7) +} + +if o.has_your_public_ip { +res << vproto.pack_32bit_field(o.your_public_ip, 2) +} + +if o.has_server_time { +res << vproto.pack_32bit_field(o.server_time, 3) +} + +if o.has_challenge { +res << vproto.pack_64bit_field(o.challenge, 4) +} + +if o.has_seconds_until_shutdown { +res << vproto.pack_uint32_field(o.seconds_until_shutdown, 5) +} + +return res +} + +pub fn cmsgsteamdatagramnosessionrelaytoclient_unpack(buf []byte) ?CMsgSteamDatagramNoSessionRelayToClient { +mut res := CMsgSteamDatagramNoSessionRelayToClient{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +7 { +res.has_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.connection_id = v +i = ii +} + +2 { +res.has_your_public_ip = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.your_public_ip = v +i = ii +} + +3 { +res.has_server_time = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.server_time = v +i = ii +} + +4 { +res.has_challenge = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.challenge = v +i = ii +} + +5 { +res.has_seconds_until_shutdown = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_until_shutdown = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramnosessionrelaytoclient() CMsgSteamDatagramNoSessionRelayToClient { +return CMsgSteamDatagramNoSessionRelayToClient{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramnosessionrelaytoclient(o CMsgSteamDatagramNoSessionRelayToClient, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramnosessionrelaytoclient(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramNoSessionRelayToClient) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramnosessionrelaytoclient_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramNoSessionRelayToPeer { +mut: +unknown_fields []vproto.UnknownField +pub mut: +legacy_relay_session_id u32 +has_legacy_relay_session_id bool +from_relay_session_id u32 +has_from_relay_session_id bool +from_connection_id u32 +has_from_connection_id bool +kludge_pad u64 +has_kludge_pad bool +} +pub fn (o &CMsgSteamDatagramNoSessionRelayToPeer) pack() []byte { +mut res := []byte{} +if o.has_legacy_relay_session_id { +res << vproto.pack_uint32_field(o.legacy_relay_session_id, 1) +} + +if o.has_from_relay_session_id { +res << vproto.pack_32bit_field(o.from_relay_session_id, 2) +} + +if o.has_from_connection_id { +res << vproto.pack_32bit_field(o.from_connection_id, 7) +} + +if o.has_kludge_pad { +res << vproto.pack_64bit_field(o.kludge_pad, 99) +} + +return res +} + +pub fn cmsgsteamdatagramnosessionrelaytopeer_unpack(buf []byte) ?CMsgSteamDatagramNoSessionRelayToPeer { +mut res := CMsgSteamDatagramNoSessionRelayToPeer{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_legacy_relay_session_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.legacy_relay_session_id = v +i = ii +} + +2 { +res.has_from_relay_session_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.from_relay_session_id = v +i = ii +} + +7 { +res.has_from_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.from_connection_id = v +i = ii +} + +99 { +res.has_kludge_pad = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.kludge_pad = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramnosessionrelaytopeer() CMsgSteamDatagramNoSessionRelayToPeer { +return CMsgSteamDatagramNoSessionRelayToPeer{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramnosessionrelaytopeer(o CMsgSteamDatagramNoSessionRelayToPeer, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramnosessionrelaytopeer(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramNoSessionRelayToPeer) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramnosessionrelaytopeer_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramClientPingSampleRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +connection_id u32 +has_connection_id bool +} +pub fn (o &CMsgSteamDatagramClientPingSampleRequest) pack() []byte { +mut res := []byte{} +if o.has_connection_id { +res << vproto.pack_32bit_field(o.connection_id, 1) +} + +return res +} + +pub fn cmsgsteamdatagramclientpingsamplerequest_unpack(buf []byte) ?CMsgSteamDatagramClientPingSampleRequest { +mut res := CMsgSteamDatagramClientPingSampleRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.connection_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramclientpingsamplerequest() CMsgSteamDatagramClientPingSampleRequest { +return CMsgSteamDatagramClientPingSampleRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramclientpingsamplerequest(o CMsgSteamDatagramClientPingSampleRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramclientpingsamplerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramClientPingSampleRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramclientpingsamplerequest_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramClientPingSampleReplyRoutingCluster { +mut: +unknown_fields []vproto.UnknownField +pub mut: +id u32 +has_id bool +front_ping_ms u32 +has_front_ping_ms bool +e2e_ping_ms u32 +has_e2e_ping_ms bool +} +pub fn (o &CMsgSteamDatagramClientPingSampleReplyRoutingCluster) pack() []byte { +mut res := []byte{} +if o.has_id { +res << vproto.pack_32bit_field(o.id, 1) +} + +if o.has_front_ping_ms { +res << vproto.pack_uint32_field(o.front_ping_ms, 2) +} + +if o.has_e2e_ping_ms { +res << vproto.pack_uint32_field(o.e2e_ping_ms, 3) +} + +return res +} + +pub fn cmsgsteamdatagramclientpingsamplereplyroutingcluster_unpack(buf []byte) ?CMsgSteamDatagramClientPingSampleReplyRoutingCluster { +mut res := CMsgSteamDatagramClientPingSampleReplyRoutingCluster{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.id = v +i = ii +} + +2 { +res.has_front_ping_ms = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.front_ping_ms = v +i = ii +} + +3 { +res.has_e2e_ping_ms = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.e2e_ping_ms = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramclientpingsamplereplyroutingcluster() CMsgSteamDatagramClientPingSampleReplyRoutingCluster { +return CMsgSteamDatagramClientPingSampleReplyRoutingCluster{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramclientpingsamplereplyroutingcluster(o CMsgSteamDatagramClientPingSampleReplyRoutingCluster, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramclientpingsamplereplyroutingcluster(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramClientPingSampleReplyRoutingCluster) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramclientpingsamplereplyroutingcluster_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramClientPingSampleReplyDataCenter { +mut: +unknown_fields []vproto.UnknownField +pub mut: +data_center_id u32 +has_data_center_id bool +via_relay_id u32 +has_via_relay_id bool +e2e_ping_ms u32 +has_e2e_ping_ms bool +} +pub fn (o &CMsgSteamDatagramClientPingSampleReplyDataCenter) pack() []byte { +mut res := []byte{} +if o.has_data_center_id { +res << vproto.pack_32bit_field(o.data_center_id, 1) +} + +if o.has_via_relay_id { +res << vproto.pack_32bit_field(o.via_relay_id, 2) +} + +if o.has_e2e_ping_ms { +res << vproto.pack_uint32_field(o.e2e_ping_ms, 3) +} + +return res +} + +pub fn cmsgsteamdatagramclientpingsamplereplydatacenter_unpack(buf []byte) ?CMsgSteamDatagramClientPingSampleReplyDataCenter { +mut res := CMsgSteamDatagramClientPingSampleReplyDataCenter{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_data_center_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.data_center_id = v +i = ii +} + +2 { +res.has_via_relay_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.via_relay_id = v +i = ii +} + +3 { +res.has_e2e_ping_ms = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.e2e_ping_ms = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramclientpingsamplereplydatacenter() CMsgSteamDatagramClientPingSampleReplyDataCenter { +return CMsgSteamDatagramClientPingSampleReplyDataCenter{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramclientpingsamplereplydatacenter(o CMsgSteamDatagramClientPingSampleReplyDataCenter, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramclientpingsamplereplydatacenter(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramClientPingSampleReplyDataCenter) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramclientpingsamplereplydatacenter_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramClientPingSampleReply { +mut: +unknown_fields []vproto.UnknownField +pub mut: +connection_id u32 +has_connection_id bool +routing_clusters []CMsgSteamDatagramClientPingSampleReplyRoutingCluster +data_centers []CMsgSteamDatagramClientPingSampleReplyDataCenter +} +pub fn (o &CMsgSteamDatagramClientPingSampleReply) pack() []byte { +mut res := []byte{} +if o.has_connection_id { +res << vproto.pack_32bit_field(o.connection_id, 1) +} + +// [packed=false] +for _, x in o.routing_clusters { +res << zzz_vproto_internal_pack_cmsgsteamdatagramclientpingsamplereplyroutingcluster(x, 2) +} + +// [packed=false] +for _, x in o.data_centers { +res << zzz_vproto_internal_pack_cmsgsteamdatagramclientpingsamplereplydatacenter(x, 3) +} + +return res +} + +pub fn cmsgsteamdatagramclientpingsamplereply_unpack(buf []byte) ?CMsgSteamDatagramClientPingSampleReply { +mut res := CMsgSteamDatagramClientPingSampleReply{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.connection_id = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramclientpingsamplereplyroutingcluster(cur_buf, tag_wiretype.wire_type)? +res.routing_clusters << v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramclientpingsamplereplydatacenter(cur_buf, tag_wiretype.wire_type)? +res.data_centers << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramclientpingsamplereply() CMsgSteamDatagramClientPingSampleReply { +return CMsgSteamDatagramClientPingSampleReply{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramclientpingsamplereply(o CMsgSteamDatagramClientPingSampleReply, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramclientpingsamplereply(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramClientPingSampleReply) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramclientpingsamplereply_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramClientSwitchedPrimaryRouterQuality { +mut: +unknown_fields []vproto.UnknownField +pub mut: +score u32 +has_score bool +front_ping u32 +has_front_ping bool +back_ping u32 +has_back_ping bool +seconds_until_down u32 +has_seconds_until_down bool +} +pub fn (o &CMsgSteamDatagramClientSwitchedPrimaryRouterQuality) pack() []byte { +mut res := []byte{} +if o.has_score { +res << vproto.pack_uint32_field(o.score, 1) +} + +if o.has_front_ping { +res << vproto.pack_uint32_field(o.front_ping, 2) +} + +if o.has_back_ping { +res << vproto.pack_uint32_field(o.back_ping, 3) +} + +if o.has_seconds_until_down { +res << vproto.pack_uint32_field(o.seconds_until_down, 4) +} + +return res +} + +pub fn cmsgsteamdatagramclientswitchedprimaryrouterquality_unpack(buf []byte) ?CMsgSteamDatagramClientSwitchedPrimaryRouterQuality { +mut res := CMsgSteamDatagramClientSwitchedPrimaryRouterQuality{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_score = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.score = v +i = ii +} + +2 { +res.has_front_ping = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.front_ping = v +i = ii +} + +3 { +res.has_back_ping = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.back_ping = v +i = ii +} + +4 { +res.has_seconds_until_down = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_until_down = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramclientswitchedprimaryrouterquality() CMsgSteamDatagramClientSwitchedPrimaryRouterQuality { +return CMsgSteamDatagramClientSwitchedPrimaryRouterQuality{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramclientswitchedprimaryrouterquality(o CMsgSteamDatagramClientSwitchedPrimaryRouterQuality, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramclientswitchedprimaryrouterquality(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramClientSwitchedPrimaryRouterQuality) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramclientswitchedprimaryrouterquality_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramClientSwitchedPrimary { +mut: +unknown_fields []vproto.UnknownField +pub mut: +connection_id u32 +has_connection_id bool +from_ip u32 +has_from_ip bool +from_port u32 +has_from_port bool +from_router_cluster u32 +has_from_router_cluster bool +from_active_time u32 +has_from_active_time bool +from_active_packets_recv u32 +has_from_active_packets_recv bool +from_dropped_reason string +has_from_dropped_reason bool +gap_ms u32 +has_gap_ms bool +from_quality_now CMsgSteamDatagramClientSwitchedPrimaryRouterQuality +has_from_quality_now bool +to_quality_now CMsgSteamDatagramClientSwitchedPrimaryRouterQuality +has_to_quality_now bool +from_quality_then CMsgSteamDatagramClientSwitchedPrimaryRouterQuality +has_from_quality_then bool +to_quality_then CMsgSteamDatagramClientSwitchedPrimaryRouterQuality +has_to_quality_then bool +} +pub fn (o &CMsgSteamDatagramClientSwitchedPrimary) pack() []byte { +mut res := []byte{} +if o.has_connection_id { +res << vproto.pack_32bit_field(o.connection_id, 1) +} + +if o.has_from_ip { +res << vproto.pack_32bit_field(o.from_ip, 2) +} + +if o.has_from_port { +res << vproto.pack_uint32_field(o.from_port, 3) +} + +if o.has_from_router_cluster { +res << vproto.pack_32bit_field(o.from_router_cluster, 4) +} + +if o.has_from_active_time { +res << vproto.pack_uint32_field(o.from_active_time, 5) +} + +if o.has_from_active_packets_recv { +res << vproto.pack_uint32_field(o.from_active_packets_recv, 6) +} + +if o.has_from_dropped_reason { +res << vproto.pack_string_field(o.from_dropped_reason, 7) +} + +if o.has_gap_ms { +res << vproto.pack_uint32_field(o.gap_ms, 8) +} + +if o.has_from_quality_now { +res << zzz_vproto_internal_pack_cmsgsteamdatagramclientswitchedprimaryrouterquality(o.from_quality_now, 9) +} + +if o.has_to_quality_now { +res << zzz_vproto_internal_pack_cmsgsteamdatagramclientswitchedprimaryrouterquality(o.to_quality_now, 10) +} + +if o.has_from_quality_then { +res << zzz_vproto_internal_pack_cmsgsteamdatagramclientswitchedprimaryrouterquality(o.from_quality_then, 11) +} + +if o.has_to_quality_then { +res << zzz_vproto_internal_pack_cmsgsteamdatagramclientswitchedprimaryrouterquality(o.to_quality_then, 12) +} + +return res +} + +pub fn cmsgsteamdatagramclientswitchedprimary_unpack(buf []byte) ?CMsgSteamDatagramClientSwitchedPrimary { +mut res := CMsgSteamDatagramClientSwitchedPrimary{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.connection_id = v +i = ii +} + +2 { +res.has_from_ip = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.from_ip = v +i = ii +} + +3 { +res.has_from_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.from_port = v +i = ii +} + +4 { +res.has_from_router_cluster = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.from_router_cluster = v +i = ii +} + +5 { +res.has_from_active_time = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.from_active_time = v +i = ii +} + +6 { +res.has_from_active_packets_recv = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.from_active_packets_recv = v +i = ii +} + +7 { +res.has_from_dropped_reason = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.from_dropped_reason = v +i = ii +} + +8 { +res.has_gap_ms = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.gap_ms = v +i = ii +} + +9 { +res.has_from_quality_now = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramclientswitchedprimaryrouterquality(cur_buf, tag_wiretype.wire_type)? +res.from_quality_now = v +i = ii +} + +10 { +res.has_to_quality_now = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramclientswitchedprimaryrouterquality(cur_buf, tag_wiretype.wire_type)? +res.to_quality_now = v +i = ii +} + +11 { +res.has_from_quality_then = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramclientswitchedprimaryrouterquality(cur_buf, tag_wiretype.wire_type)? +res.from_quality_then = v +i = ii +} + +12 { +res.has_to_quality_then = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramclientswitchedprimaryrouterquality(cur_buf, tag_wiretype.wire_type)? +res.to_quality_then = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramclientswitchedprimary() CMsgSteamDatagramClientSwitchedPrimary { +return CMsgSteamDatagramClientSwitchedPrimary{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramclientswitchedprimary(o CMsgSteamDatagramClientSwitchedPrimary, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramclientswitchedprimary(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramClientSwitchedPrimary) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramclientswitchedprimary_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramConnectRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +connection_id u32 +has_connection_id bool +my_timestamp u64 +has_my_timestamp bool +ping_est_ms u32 +has_ping_est_ms bool +virtual_port u32 +has_virtual_port bool +gameserver_relay_session_id u32 +has_gameserver_relay_session_id bool +crypt CMsgSteamDatagramSessionCryptInfoSigned +has_crypt bool +cert CMsgSteamDatagramCertificateSigned +has_cert bool +routing_secret u64 +has_routing_secret bool +legacy_client_steam_id u64 +has_legacy_client_steam_id bool +} +pub fn (o &CMsgSteamDatagramConnectRequest) pack() []byte { +mut res := []byte{} +if o.has_connection_id { +res << vproto.pack_32bit_field(o.connection_id, 1) +} + +if o.has_my_timestamp { +res << vproto.pack_64bit_field(o.my_timestamp, 4) +} + +if o.has_ping_est_ms { +res << vproto.pack_uint32_field(o.ping_est_ms, 5) +} + +if o.has_virtual_port { +res << vproto.pack_uint32_field(o.virtual_port, 9) +} + +if o.has_gameserver_relay_session_id { +res << vproto.pack_uint32_field(o.gameserver_relay_session_id, 2) +} + +if o.has_crypt { +res << zzz_vproto_internal_pack_cmsgsteamdatagramsessioncryptinfosigned(o.crypt, 6) +} + +if o.has_cert { +res << zzz_vproto_internal_pack_cmsgsteamdatagramcertificatesigned(o.cert, 7) +} + +if o.has_routing_secret { +res << vproto.pack_64bit_field(o.routing_secret, 10) +} + +if o.has_legacy_client_steam_id { +res << vproto.pack_64bit_field(o.legacy_client_steam_id, 3) +} + +return res +} + +pub fn cmsgsteamdatagramconnectrequest_unpack(buf []byte) ?CMsgSteamDatagramConnectRequest { +mut res := CMsgSteamDatagramConnectRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.connection_id = v +i = ii +} + +4 { +res.has_my_timestamp = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.my_timestamp = v +i = ii +} + +5 { +res.has_ping_est_ms = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ping_est_ms = v +i = ii +} + +9 { +res.has_virtual_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.virtual_port = v +i = ii +} + +2 { +res.has_gameserver_relay_session_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.gameserver_relay_session_id = v +i = ii +} + +6 { +res.has_crypt = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramsessioncryptinfosigned(cur_buf, tag_wiretype.wire_type)? +res.crypt = v +i = ii +} + +7 { +res.has_cert = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramcertificatesigned(cur_buf, tag_wiretype.wire_type)? +res.cert = v +i = ii +} + +10 { +res.has_routing_secret = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.routing_secret = v +i = ii +} + +3 { +res.has_legacy_client_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.legacy_client_steam_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramconnectrequest() CMsgSteamDatagramConnectRequest { +return CMsgSteamDatagramConnectRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramconnectrequest(o CMsgSteamDatagramConnectRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramconnectrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramConnectRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramconnectrequest_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramConnectOK { +mut: +unknown_fields []vproto.UnknownField +pub mut: +client_connection_id u32 +has_client_connection_id bool +server_connection_id u32 +has_server_connection_id bool +your_timestamp u64 +has_your_timestamp bool +delay_time_usec u32 +has_delay_time_usec bool +gameserver_relay_session_id u32 +has_gameserver_relay_session_id bool +crypt CMsgSteamDatagramSessionCryptInfoSigned +has_crypt bool +cert CMsgSteamDatagramCertificateSigned +has_cert bool +} +pub fn (o &CMsgSteamDatagramConnectOK) pack() []byte { +mut res := []byte{} +if o.has_client_connection_id { +res << vproto.pack_32bit_field(o.client_connection_id, 1) +} + +if o.has_server_connection_id { +res << vproto.pack_32bit_field(o.server_connection_id, 7) +} + +if o.has_your_timestamp { +res << vproto.pack_64bit_field(o.your_timestamp, 3) +} + +if o.has_delay_time_usec { +res << vproto.pack_uint32_field(o.delay_time_usec, 4) +} + +if o.has_gameserver_relay_session_id { +res << vproto.pack_uint32_field(o.gameserver_relay_session_id, 2) +} + +if o.has_crypt { +res << zzz_vproto_internal_pack_cmsgsteamdatagramsessioncryptinfosigned(o.crypt, 5) +} + +if o.has_cert { +res << zzz_vproto_internal_pack_cmsgsteamdatagramcertificatesigned(o.cert, 6) +} + +return res +} + +pub fn cmsgsteamdatagramconnectok_unpack(buf []byte) ?CMsgSteamDatagramConnectOK { +mut res := CMsgSteamDatagramConnectOK{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_client_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.client_connection_id = v +i = ii +} + +7 { +res.has_server_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.server_connection_id = v +i = ii +} + +3 { +res.has_your_timestamp = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.your_timestamp = v +i = ii +} + +4 { +res.has_delay_time_usec = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.delay_time_usec = v +i = ii +} + +2 { +res.has_gameserver_relay_session_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.gameserver_relay_session_id = v +i = ii +} + +5 { +res.has_crypt = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramsessioncryptinfosigned(cur_buf, tag_wiretype.wire_type)? +res.crypt = v +i = ii +} + +6 { +res.has_cert = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramcertificatesigned(cur_buf, tag_wiretype.wire_type)? +res.cert = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramconnectok() CMsgSteamDatagramConnectOK { +return CMsgSteamDatagramConnectOK{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramconnectok(o CMsgSteamDatagramConnectOK, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramconnectok(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramConnectOK) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramconnectok_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamNetworkingP2PSdrroutingSummary { +mut: +unknown_fields []vproto.UnknownField +pub mut: +initial_ping u32 +has_initial_ping bool +initial_ping_front_local u32 +has_initial_ping_front_local bool +initial_ping_front_remote u32 +has_initial_ping_front_remote bool +initial_score u32 +has_initial_score bool +initial_pop_local u32 +has_initial_pop_local bool +initial_pop_remote u32 +has_initial_pop_remote bool +negotiation_ms u32 +has_negotiation_ms bool +selected_seconds u32 +has_selected_seconds bool +} +pub fn (o &CMsgSteamNetworkingP2PSdrroutingSummary) pack() []byte { +mut res := []byte{} +if o.has_initial_ping { +res << vproto.pack_uint32_field(o.initial_ping, 1) +} + +if o.has_initial_ping_front_local { +res << vproto.pack_uint32_field(o.initial_ping_front_local, 2) +} + +if o.has_initial_ping_front_remote { +res << vproto.pack_uint32_field(o.initial_ping_front_remote, 3) +} + +if o.has_initial_score { +res << vproto.pack_uint32_field(o.initial_score, 4) +} + +if o.has_initial_pop_local { +res << vproto.pack_32bit_field(o.initial_pop_local, 5) +} + +if o.has_initial_pop_remote { +res << vproto.pack_32bit_field(o.initial_pop_remote, 6) +} + +if o.has_negotiation_ms { +res << vproto.pack_uint32_field(o.negotiation_ms, 7) +} + +if o.has_selected_seconds { +res << vproto.pack_uint32_field(o.selected_seconds, 8) +} + +return res +} + +pub fn cmsgsteamnetworkingp2psdrroutingsummary_unpack(buf []byte) ?CMsgSteamNetworkingP2PSdrroutingSummary { +mut res := CMsgSteamNetworkingP2PSdrroutingSummary{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_initial_ping = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.initial_ping = v +i = ii +} + +2 { +res.has_initial_ping_front_local = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.initial_ping_front_local = v +i = ii +} + +3 { +res.has_initial_ping_front_remote = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.initial_ping_front_remote = v +i = ii +} + +4 { +res.has_initial_score = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.initial_score = v +i = ii +} + +5 { +res.has_initial_pop_local = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.initial_pop_local = v +i = ii +} + +6 { +res.has_initial_pop_remote = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.initial_pop_remote = v +i = ii +} + +7 { +res.has_negotiation_ms = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.negotiation_ms = v +i = ii +} + +8 { +res.has_selected_seconds = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.selected_seconds = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamnetworkingp2psdrroutingsummary() CMsgSteamNetworkingP2PSdrroutingSummary { +return CMsgSteamNetworkingP2PSdrroutingSummary{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamnetworkingp2psdrroutingsummary(o CMsgSteamNetworkingP2PSdrroutingSummary, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamnetworkingp2psdrroutingsummary(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamNetworkingP2PSdrroutingSummary) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamnetworkingp2psdrroutingsummary_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramP2PRoutingSummary { +mut: +unknown_fields []vproto.UnknownField +pub mut: +ice CMsgSteamNetworkingICesessionSummary +has_ice bool +sdr CMsgSteamNetworkingP2PSdrroutingSummary +has_sdr bool +} +pub fn (o &CMsgSteamDatagramP2PRoutingSummary) pack() []byte { +mut res := []byte{} +if o.has_ice { +res << zzz_vproto_internal_pack_cmsgsteamnetworkingicesessionsummary(o.ice, 2) +} + +if o.has_sdr { +res << zzz_vproto_internal_pack_cmsgsteamnetworkingp2psdrroutingsummary(o.sdr, 3) +} + +return res +} + +pub fn cmsgsteamdatagramp2proutingsummary_unpack(buf []byte) ?CMsgSteamDatagramP2PRoutingSummary { +mut res := CMsgSteamDatagramP2PRoutingSummary{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +2 { +res.has_ice = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamnetworkingicesessionsummary(cur_buf, tag_wiretype.wire_type)? +res.ice = v +i = ii +} + +3 { +res.has_sdr = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamnetworkingp2psdrroutingsummary(cur_buf, tag_wiretype.wire_type)? +res.sdr = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramp2proutingsummary() CMsgSteamDatagramP2PRoutingSummary { +return CMsgSteamDatagramP2PRoutingSummary{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramp2proutingsummary(o CMsgSteamDatagramP2PRoutingSummary, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramp2proutingsummary(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramP2PRoutingSummary) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramp2proutingsummary_unpack(v)? +return i, unpacked +} +[_allow_multiple_values] +enum CMsgSteamDatagramConnectionClosedERelayMode { +@none = 0 +endtoend = 1 +closedbypeer = 2 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_cmsgsteamdatagramconnectionclosederelaymode(e CMsgSteamDatagramConnectionClosedERelayMode, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionclosederelaymode(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramConnectionClosedERelayMode) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, CMsgSteamDatagramConnectionClosedERelayMode(v) +} +pub struct CMsgSteamDatagramConnectionClosed { +mut: +unknown_fields []vproto.UnknownField +pub mut: +to_connection_id u32 +has_to_connection_id bool +from_connection_id u32 +has_from_connection_id bool +from_identity_string string +has_from_identity_string bool +legacy_from_identity_binary CMsgSteamNetworkingIdentityLegacyBinary +has_legacy_from_identity_binary bool +legacy_from_steam_id u64 +has_legacy_from_steam_id bool +legacy_gameserver_relay_session_id u32 +has_legacy_gameserver_relay_session_id bool +to_relay_session_id u32 +has_to_relay_session_id bool +from_relay_session_id u32 +has_from_relay_session_id bool +forward_target_relay_routing_token []byte +has_forward_target_relay_routing_token bool +forward_target_revision u32 +has_forward_target_revision bool +relay_mode CMsgSteamDatagramConnectionClosedERelayMode +has_relay_mode bool +debug string +has_debug bool +reason_code u32 +has_reason_code bool +routing_secret u64 +has_routing_secret bool +not_primary_session bool +has_not_primary_session bool +not_primary_transport bool +has_not_primary_transport bool +quality_relay CMsgSteamDatagramConnectionQuality +has_quality_relay bool +quality_e2e CMsgSteamDatagramConnectionQuality +has_quality_e2e bool +p2p_routing_summary CMsgSteamDatagramP2PRoutingSummary +has_p2p_routing_summary bool +} +pub fn (o &CMsgSteamDatagramConnectionClosed) pack() []byte { +mut res := []byte{} +if o.has_to_connection_id { +res << vproto.pack_32bit_field(o.to_connection_id, 7) +} + +if o.has_from_connection_id { +res << vproto.pack_32bit_field(o.from_connection_id, 8) +} + +if o.has_from_identity_string { +res << vproto.pack_string_field(o.from_identity_string, 15) +} + +if o.has_legacy_from_identity_binary { +res << zzz_vproto_internal_pack_cmsgsteamnetworkingidentitylegacybinary(o.legacy_from_identity_binary, 13) +} + +if o.has_legacy_from_steam_id { +res << vproto.pack_64bit_field(o.legacy_from_steam_id, 3) +} + +if o.has_legacy_gameserver_relay_session_id { +res << vproto.pack_uint32_field(o.legacy_gameserver_relay_session_id, 2) +} + +if o.has_to_relay_session_id { +res << vproto.pack_32bit_field(o.to_relay_session_id, 9) +} + +if o.has_from_relay_session_id { +res << vproto.pack_32bit_field(o.from_relay_session_id, 10) +} + +if o.has_forward_target_relay_routing_token { +res << vproto.pack_bytes_field(o.forward_target_relay_routing_token, 11) +} + +if o.has_forward_target_revision { +res << vproto.pack_uint32_field(o.forward_target_revision, 12) +} + +if o.has_relay_mode { +res << zzz_vproto_internal_pack_cmsgsteamdatagramconnectionclosederelaymode(o.relay_mode, 4) +} + +if o.has_debug { +res << vproto.pack_string_field(o.debug, 5) +} + +if o.has_reason_code { +res << vproto.pack_uint32_field(o.reason_code, 6) +} + +if o.has_routing_secret { +res << vproto.pack_64bit_field(o.routing_secret, 14) +} + +if o.has_not_primary_session { +res << vproto.pack_bool_field(o.not_primary_session, 16) +} + +if o.has_not_primary_transport { +res << vproto.pack_bool_field(o.not_primary_transport, 19) +} + +if o.has_quality_relay { +res << zzz_vproto_internal_pack_cmsgsteamdatagramconnectionquality(o.quality_relay, 17) +} + +if o.has_quality_e2e { +res << zzz_vproto_internal_pack_cmsgsteamdatagramconnectionquality(o.quality_e2e, 18) +} + +if o.has_p2p_routing_summary { +res << zzz_vproto_internal_pack_cmsgsteamdatagramp2proutingsummary(o.p2p_routing_summary, 21) +} + +return res +} + +pub fn cmsgsteamdatagramconnectionclosed_unpack(buf []byte) ?CMsgSteamDatagramConnectionClosed { +mut res := CMsgSteamDatagramConnectionClosed{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +7 { +res.has_to_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.to_connection_id = v +i = ii +} + +8 { +res.has_from_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.from_connection_id = v +i = ii +} + +15 { +res.has_from_identity_string = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.from_identity_string = v +i = ii +} + +13 { +res.has_legacy_from_identity_binary = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamnetworkingidentitylegacybinary(cur_buf, tag_wiretype.wire_type)? +res.legacy_from_identity_binary = v +i = ii +} + +3 { +res.has_legacy_from_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.legacy_from_steam_id = v +i = ii +} + +2 { +res.has_legacy_gameserver_relay_session_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.legacy_gameserver_relay_session_id = v +i = ii +} + +9 { +res.has_to_relay_session_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.to_relay_session_id = v +i = ii +} + +10 { +res.has_from_relay_session_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.from_relay_session_id = v +i = ii +} + +11 { +res.has_forward_target_relay_routing_token = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.forward_target_relay_routing_token = v +i = ii +} + +12 { +res.has_forward_target_revision = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.forward_target_revision = v +i = ii +} + +4 { +res.has_relay_mode = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionclosederelaymode(cur_buf, tag_wiretype.wire_type)? +res.relay_mode = v +i = ii +} + +5 { +res.has_debug = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.debug = v +i = ii +} + +6 { +res.has_reason_code = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.reason_code = v +i = ii +} + +14 { +res.has_routing_secret = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.routing_secret = v +i = ii +} + +16 { +res.has_not_primary_session = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.not_primary_session = v +i = ii +} + +19 { +res.has_not_primary_transport = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.not_primary_transport = v +i = ii +} + +17 { +res.has_quality_relay = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionquality(cur_buf, tag_wiretype.wire_type)? +res.quality_relay = v +i = ii +} + +18 { +res.has_quality_e2e = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionquality(cur_buf, tag_wiretype.wire_type)? +res.quality_e2e = v +i = ii +} + +21 { +res.has_p2p_routing_summary = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramp2proutingsummary(cur_buf, tag_wiretype.wire_type)? +res.p2p_routing_summary = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramconnectionclosed() CMsgSteamDatagramConnectionClosed { +return CMsgSteamDatagramConnectionClosed{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramconnectionclosed(o CMsgSteamDatagramConnectionClosed, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionclosed(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramConnectionClosed) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramconnectionclosed_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramNoConnection { +mut: +unknown_fields []vproto.UnknownField +pub mut: +to_connection_id u32 +has_to_connection_id bool +from_connection_id u32 +has_from_connection_id bool +legacy_gameserver_relay_session_id u32 +has_legacy_gameserver_relay_session_id bool +to_relay_session_id u32 +has_to_relay_session_id bool +from_relay_session_id u32 +has_from_relay_session_id bool +from_identity_string string +has_from_identity_string bool +legacy_from_steam_id u64 +has_legacy_from_steam_id bool +end_to_end bool +has_end_to_end bool +not_primary_session bool +has_not_primary_session bool +not_primary_transport bool +has_not_primary_transport bool +quality_relay CMsgSteamDatagramConnectionQuality +has_quality_relay bool +quality_e2e CMsgSteamDatagramConnectionQuality +has_quality_e2e bool +p2p_routing_summary CMsgSteamDatagramP2PRoutingSummary +has_p2p_routing_summary bool +routing_secret u64 +has_routing_secret bool +dummy_pad u32 +has_dummy_pad bool +} +pub fn (o &CMsgSteamDatagramNoConnection) pack() []byte { +mut res := []byte{} +if o.has_to_connection_id { +res << vproto.pack_32bit_field(o.to_connection_id, 5) +} + +if o.has_from_connection_id { +res << vproto.pack_32bit_field(o.from_connection_id, 6) +} + +if o.has_legacy_gameserver_relay_session_id { +res << vproto.pack_uint32_field(o.legacy_gameserver_relay_session_id, 2) +} + +if o.has_to_relay_session_id { +res << vproto.pack_32bit_field(o.to_relay_session_id, 9) +} + +if o.has_from_relay_session_id { +res << vproto.pack_32bit_field(o.from_relay_session_id, 10) +} + +if o.has_from_identity_string { +res << vproto.pack_string_field(o.from_identity_string, 7) +} + +if o.has_legacy_from_steam_id { +res << vproto.pack_64bit_field(o.legacy_from_steam_id, 3) +} + +if o.has_end_to_end { +res << vproto.pack_bool_field(o.end_to_end, 4) +} + +if o.has_not_primary_session { +res << vproto.pack_bool_field(o.not_primary_session, 12) +} + +if o.has_not_primary_transport { +res << vproto.pack_bool_field(o.not_primary_transport, 15) +} + +if o.has_quality_relay { +res << zzz_vproto_internal_pack_cmsgsteamdatagramconnectionquality(o.quality_relay, 13) +} + +if o.has_quality_e2e { +res << zzz_vproto_internal_pack_cmsgsteamdatagramconnectionquality(o.quality_e2e, 14) +} + +if o.has_p2p_routing_summary { +res << zzz_vproto_internal_pack_cmsgsteamdatagramp2proutingsummary(o.p2p_routing_summary, 16) +} + +if o.has_routing_secret { +res << vproto.pack_64bit_field(o.routing_secret, 11) +} + +if o.has_dummy_pad { +res << vproto.pack_32bit_field(o.dummy_pad, 1023) +} + +return res +} + +pub fn cmsgsteamdatagramnoconnection_unpack(buf []byte) ?CMsgSteamDatagramNoConnection { +mut res := CMsgSteamDatagramNoConnection{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +5 { +res.has_to_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.to_connection_id = v +i = ii +} + +6 { +res.has_from_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.from_connection_id = v +i = ii +} + +2 { +res.has_legacy_gameserver_relay_session_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.legacy_gameserver_relay_session_id = v +i = ii +} + +9 { +res.has_to_relay_session_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.to_relay_session_id = v +i = ii +} + +10 { +res.has_from_relay_session_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.from_relay_session_id = v +i = ii +} + +7 { +res.has_from_identity_string = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.from_identity_string = v +i = ii +} + +3 { +res.has_legacy_from_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.legacy_from_steam_id = v +i = ii +} + +4 { +res.has_end_to_end = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.end_to_end = v +i = ii +} + +12 { +res.has_not_primary_session = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.not_primary_session = v +i = ii +} + +15 { +res.has_not_primary_transport = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.not_primary_transport = v +i = ii +} + +13 { +res.has_quality_relay = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionquality(cur_buf, tag_wiretype.wire_type)? +res.quality_relay = v +i = ii +} + +14 { +res.has_quality_e2e = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionquality(cur_buf, tag_wiretype.wire_type)? +res.quality_e2e = v +i = ii +} + +16 { +res.has_p2p_routing_summary = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramp2proutingsummary(cur_buf, tag_wiretype.wire_type)? +res.p2p_routing_summary = v +i = ii +} + +11 { +res.has_routing_secret = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.routing_secret = v +i = ii +} + +1023 { +res.has_dummy_pad = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.dummy_pad = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramnoconnection() CMsgSteamDatagramNoConnection { +return CMsgSteamDatagramNoConnection{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramnoconnection(o CMsgSteamDatagramNoConnection, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramnoconnection(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramNoConnection) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramnoconnection_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramGameserverSessionRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +ticket []byte +has_ticket bool +challenge_time u32 +has_challenge_time bool +challenge u64 +has_challenge bool +client_connection_id u32 +has_client_connection_id bool +server_connection_id u32 +has_server_connection_id bool +network_config_version u32 +has_network_config_version bool +protocol_version u32 +has_protocol_version bool +} +pub fn (o &CMsgSteamDatagramGameserverSessionRequest) pack() []byte { +mut res := []byte{} +if o.has_ticket { +res << vproto.pack_bytes_field(o.ticket, 1) +} + +if o.has_challenge_time { +res << vproto.pack_32bit_field(o.challenge_time, 3) +} + +if o.has_challenge { +res << vproto.pack_64bit_field(o.challenge, 4) +} + +if o.has_client_connection_id { +res << vproto.pack_32bit_field(o.client_connection_id, 5) +} + +if o.has_server_connection_id { +res << vproto.pack_32bit_field(o.server_connection_id, 8) +} + +if o.has_network_config_version { +res << vproto.pack_uint32_field(o.network_config_version, 6) +} + +if o.has_protocol_version { +res << vproto.pack_uint32_field(o.protocol_version, 7) +} + +return res +} + +pub fn cmsgsteamdatagramgameserversessionrequest_unpack(buf []byte) ?CMsgSteamDatagramGameserverSessionRequest { +mut res := CMsgSteamDatagramGameserverSessionRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_ticket = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.ticket = v +i = ii +} + +3 { +res.has_challenge_time = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.challenge_time = v +i = ii +} + +4 { +res.has_challenge = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.challenge = v +i = ii +} + +5 { +res.has_client_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.client_connection_id = v +i = ii +} + +8 { +res.has_server_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.server_connection_id = v +i = ii +} + +6 { +res.has_network_config_version = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.network_config_version = v +i = ii +} + +7 { +res.has_protocol_version = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.protocol_version = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramgameserversessionrequest() CMsgSteamDatagramGameserverSessionRequest { +return CMsgSteamDatagramGameserverSessionRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramgameserversessionrequest(o CMsgSteamDatagramGameserverSessionRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramgameserversessionrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramGameserverSessionRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramgameserversessionrequest_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramGameserverSessionEstablished { +mut: +unknown_fields []vproto.UnknownField +pub mut: +connection_id u32 +has_connection_id bool +gameserver_identity_string string +has_gameserver_identity_string bool +seconds_until_shutdown u32 +has_seconds_until_shutdown bool +seq_num_r2c u32 +has_seq_num_r2c bool +dummy_legacy_identity_binary []byte +has_dummy_legacy_identity_binary bool +legacy_gameserver_steamid u64 +has_legacy_gameserver_steamid bool +} +pub fn (o &CMsgSteamDatagramGameserverSessionEstablished) pack() []byte { +mut res := []byte{} +if o.has_connection_id { +res << vproto.pack_32bit_field(o.connection_id, 1) +} + +if o.has_gameserver_identity_string { +res << vproto.pack_string_field(o.gameserver_identity_string, 2) +} + +if o.has_seconds_until_shutdown { +res << vproto.pack_uint32_field(o.seconds_until_shutdown, 4) +} + +if o.has_seq_num_r2c { +res << vproto.pack_uint32_field(o.seq_num_r2c, 6) +} + +if o.has_dummy_legacy_identity_binary { +res << vproto.pack_bytes_field(o.dummy_legacy_identity_binary, 7) +} + +if o.has_legacy_gameserver_steamid { +res << vproto.pack_64bit_field(o.legacy_gameserver_steamid, 3) +} + +return res +} + +pub fn cmsgsteamdatagramgameserversessionestablished_unpack(buf []byte) ?CMsgSteamDatagramGameserverSessionEstablished { +mut res := CMsgSteamDatagramGameserverSessionEstablished{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.connection_id = v +i = ii +} + +2 { +res.has_gameserver_identity_string = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.gameserver_identity_string = v +i = ii +} + +4 { +res.has_seconds_until_shutdown = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_until_shutdown = v +i = ii +} + +6 { +res.has_seq_num_r2c = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seq_num_r2c = v +i = ii +} + +7 { +res.has_dummy_legacy_identity_binary = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.dummy_legacy_identity_binary = v +i = ii +} + +3 { +res.has_legacy_gameserver_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.legacy_gameserver_steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramgameserversessionestablished() CMsgSteamDatagramGameserverSessionEstablished { +return CMsgSteamDatagramGameserverSessionEstablished{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramgameserversessionestablished(o CMsgSteamDatagramGameserverSessionEstablished, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramgameserversessionestablished(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramGameserverSessionEstablished) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramgameserversessionestablished_unpack(v)? +return i, unpacked +} +[_allow_multiple_values] +enum CMsgSteamDatagramConnectionStatsClientToRouterFlags { +ack_request_relay = 1 +ack_request_e2e = 2 +ack_request_immediate = 4 +not_primary_session = 8 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_cmsgsteamdatagramconnectionstatsclienttorouterflags(e CMsgSteamDatagramConnectionStatsClientToRouterFlags, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionstatsclienttorouterflags(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramConnectionStatsClientToRouterFlags) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, CMsgSteamDatagramConnectionStatsClientToRouterFlags(v) +} +pub struct CMsgSteamDatagramConnectionStatsClientToRouter { +mut: +unknown_fields []vproto.UnknownField +pub mut: +quality_relay CMsgSteamDatagramConnectionQuality +has_quality_relay bool +quality_e2e CMsgSteamDatagramConnectionQuality +has_quality_e2e bool +ack_relay []u32 +legacy_ack_e2e []u32 +flags u32 +has_flags bool +client_connection_id u32 +has_client_connection_id bool +seq_num_c2r u32 +has_seq_num_c2r bool +seq_num_e2e u32 +has_seq_num_e2e bool +} +pub fn (o &CMsgSteamDatagramConnectionStatsClientToRouter) pack() []byte { +mut res := []byte{} +if o.has_quality_relay { +res << zzz_vproto_internal_pack_cmsgsteamdatagramconnectionquality(o.quality_relay, 1) +} + +if o.has_quality_e2e { +res << zzz_vproto_internal_pack_cmsgsteamdatagramconnectionquality(o.quality_e2e, 2) +} + +// [packed=false] +for _, x in o.ack_relay { +res << vproto.pack_32bit_field(x, 4) +} + +// [packed=false] +for _, x in o.legacy_ack_e2e { +res << vproto.pack_32bit_field(x, 5) +} + +if o.has_flags { +res << vproto.pack_uint32_field(o.flags, 6) +} + +if o.has_client_connection_id { +res << vproto.pack_32bit_field(o.client_connection_id, 8) +} + +if o.has_seq_num_c2r { +res << vproto.pack_uint32_field(o.seq_num_c2r, 9) +} + +if o.has_seq_num_e2e { +res << vproto.pack_uint32_field(o.seq_num_e2e, 10) +} + +return res +} + +pub fn cmsgsteamdatagramconnectionstatsclienttorouter_unpack(buf []byte) ?CMsgSteamDatagramConnectionStatsClientToRouter { +mut res := CMsgSteamDatagramConnectionStatsClientToRouter{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_quality_relay = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionquality(cur_buf, tag_wiretype.wire_type)? +res.quality_relay = v +i = ii +} + +2 { +res.has_quality_e2e = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionquality(cur_buf, tag_wiretype.wire_type)? +res.quality_e2e = v +i = ii +} + +4 { +// [packed=false] +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.ack_relay << v +i = ii +} + +5 { +// [packed=false] +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.legacy_ack_e2e << v +i = ii +} + +6 { +res.has_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.flags = v +i = ii +} + +8 { +res.has_client_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.client_connection_id = v +i = ii +} + +9 { +res.has_seq_num_c2r = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seq_num_c2r = v +i = ii +} + +10 { +res.has_seq_num_e2e = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seq_num_e2e = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramconnectionstatsclienttorouter() CMsgSteamDatagramConnectionStatsClientToRouter { +return CMsgSteamDatagramConnectionStatsClientToRouter{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramconnectionstatsclienttorouter(o CMsgSteamDatagramConnectionStatsClientToRouter, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionstatsclienttorouter(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramConnectionStatsClientToRouter) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramconnectionstatsclienttorouter_unpack(v)? +return i, unpacked +} +[_allow_multiple_values] +enum CMsgSteamDatagramConnectionStatsRouterToClientFlags { +ack_request_relay = 1 +ack_request_e2e = 2 +ack_request_immediate = 4 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_cmsgsteamdatagramconnectionstatsroutertoclientflags(e CMsgSteamDatagramConnectionStatsRouterToClientFlags, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionstatsroutertoclientflags(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramConnectionStatsRouterToClientFlags) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, CMsgSteamDatagramConnectionStatsRouterToClientFlags(v) +} +pub struct CMsgSteamDatagramConnectionStatsRouterToClient { +mut: +unknown_fields []vproto.UnknownField +pub mut: +quality_relay CMsgSteamDatagramConnectionQuality +has_quality_relay bool +quality_e2e CMsgSteamDatagramConnectionQuality +has_quality_e2e bool +seconds_until_shutdown u32 +has_seconds_until_shutdown bool +migrate_request_ip u32 +has_migrate_request_ip bool +migrate_request_port u32 +has_migrate_request_port bool +scoring_penalty_relay_cluster u32 +has_scoring_penalty_relay_cluster bool +ack_relay []u32 +legacy_ack_e2e []u32 +flags u32 +has_flags bool +client_connection_id u32 +has_client_connection_id bool +seq_num_r2c u32 +has_seq_num_r2c bool +seq_num_e2e u32 +has_seq_num_e2e bool +} +pub fn (o &CMsgSteamDatagramConnectionStatsRouterToClient) pack() []byte { +mut res := []byte{} +if o.has_quality_relay { +res << zzz_vproto_internal_pack_cmsgsteamdatagramconnectionquality(o.quality_relay, 1) +} + +if o.has_quality_e2e { +res << zzz_vproto_internal_pack_cmsgsteamdatagramconnectionquality(o.quality_e2e, 2) +} + +if o.has_seconds_until_shutdown { +res << vproto.pack_uint32_field(o.seconds_until_shutdown, 6) +} + +if o.has_migrate_request_ip { +res << vproto.pack_32bit_field(o.migrate_request_ip, 10) +} + +if o.has_migrate_request_port { +res << vproto.pack_uint32_field(o.migrate_request_port, 11) +} + +if o.has_scoring_penalty_relay_cluster { +res << vproto.pack_uint32_field(o.scoring_penalty_relay_cluster, 12) +} + +// [packed=false] +for _, x in o.ack_relay { +res << vproto.pack_32bit_field(x, 13) +} + +// [packed=false] +for _, x in o.legacy_ack_e2e { +res << vproto.pack_32bit_field(x, 14) +} + +if o.has_flags { +res << vproto.pack_uint32_field(o.flags, 15) +} + +if o.has_client_connection_id { +res << vproto.pack_32bit_field(o.client_connection_id, 7) +} + +if o.has_seq_num_r2c { +res << vproto.pack_uint32_field(o.seq_num_r2c, 8) +} + +if o.has_seq_num_e2e { +res << vproto.pack_uint32_field(o.seq_num_e2e, 9) +} + +return res +} + +pub fn cmsgsteamdatagramconnectionstatsroutertoclient_unpack(buf []byte) ?CMsgSteamDatagramConnectionStatsRouterToClient { +mut res := CMsgSteamDatagramConnectionStatsRouterToClient{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_quality_relay = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionquality(cur_buf, tag_wiretype.wire_type)? +res.quality_relay = v +i = ii +} + +2 { +res.has_quality_e2e = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionquality(cur_buf, tag_wiretype.wire_type)? +res.quality_e2e = v +i = ii +} + +6 { +res.has_seconds_until_shutdown = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_until_shutdown = v +i = ii +} + +10 { +res.has_migrate_request_ip = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.migrate_request_ip = v +i = ii +} + +11 { +res.has_migrate_request_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.migrate_request_port = v +i = ii +} + +12 { +res.has_scoring_penalty_relay_cluster = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.scoring_penalty_relay_cluster = v +i = ii +} + +13 { +// [packed=false] +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.ack_relay << v +i = ii +} + +14 { +// [packed=false] +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.legacy_ack_e2e << v +i = ii +} + +15 { +res.has_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.flags = v +i = ii +} + +7 { +res.has_client_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.client_connection_id = v +i = ii +} + +8 { +res.has_seq_num_r2c = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seq_num_r2c = v +i = ii +} + +9 { +res.has_seq_num_e2e = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seq_num_e2e = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramconnectionstatsroutertoclient() CMsgSteamDatagramConnectionStatsRouterToClient { +return CMsgSteamDatagramConnectionStatsRouterToClient{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramconnectionstatsroutertoclient(o CMsgSteamDatagramConnectionStatsRouterToClient, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionstatsroutertoclient(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramConnectionStatsRouterToClient) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramconnectionstatsroutertoclient_unpack(v)? +return i, unpacked +} +[_allow_multiple_values] +enum CMsgSteamDatagramConnectionStatsRouterToServerFlags { +ack_request_relay = 1 +ack_request_e2e = 2 +ack_request_immediate = 4 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_cmsgsteamdatagramconnectionstatsroutertoserverflags(e CMsgSteamDatagramConnectionStatsRouterToServerFlags, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionstatsroutertoserverflags(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramConnectionStatsRouterToServerFlags) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, CMsgSteamDatagramConnectionStatsRouterToServerFlags(v) +} +pub struct CMsgSteamDatagramConnectionStatsRouterToServer { +mut: +unknown_fields []vproto.UnknownField +pub mut: +quality_relay CMsgSteamDatagramConnectionQuality +has_quality_relay bool +quality_e2e CMsgSteamDatagramConnectionQuality +has_quality_e2e bool +ack_relay []u32 +legacy_ack_e2e []u32 +flags u32 +has_flags bool +seq_num_r2s u32 +has_seq_num_r2s bool +seq_num_e2e u32 +has_seq_num_e2e bool +client_identity_string string +has_client_identity_string bool +legacy_client_steam_id u64 +has_legacy_client_steam_id bool +relay_session_id u32 +has_relay_session_id bool +client_connection_id u32 +has_client_connection_id bool +server_connection_id u32 +has_server_connection_id bool +routing_secret u64 +has_routing_secret bool +} +pub fn (o &CMsgSteamDatagramConnectionStatsRouterToServer) pack() []byte { +mut res := []byte{} +if o.has_quality_relay { +res << zzz_vproto_internal_pack_cmsgsteamdatagramconnectionquality(o.quality_relay, 1) +} + +if o.has_quality_e2e { +res << zzz_vproto_internal_pack_cmsgsteamdatagramconnectionquality(o.quality_e2e, 2) +} + +// [packed=false] +for _, x in o.ack_relay { +res << vproto.pack_32bit_field(x, 10) +} + +// [packed=false] +for _, x in o.legacy_ack_e2e { +res << vproto.pack_32bit_field(x, 11) +} + +if o.has_flags { +res << vproto.pack_uint32_field(o.flags, 12) +} + +if o.has_seq_num_r2s { +res << vproto.pack_uint32_field(o.seq_num_r2s, 5) +} + +if o.has_seq_num_e2e { +res << vproto.pack_uint32_field(o.seq_num_e2e, 6) +} + +if o.has_client_identity_string { +res << vproto.pack_string_field(o.client_identity_string, 15) +} + +if o.has_legacy_client_steam_id { +res << vproto.pack_64bit_field(o.legacy_client_steam_id, 7) +} + +if o.has_relay_session_id { +res << vproto.pack_uint32_field(o.relay_session_id, 8) +} + +if o.has_client_connection_id { +res << vproto.pack_32bit_field(o.client_connection_id, 9) +} + +if o.has_server_connection_id { +res << vproto.pack_32bit_field(o.server_connection_id, 13) +} + +if o.has_routing_secret { +res << vproto.pack_64bit_field(o.routing_secret, 14) +} + +return res +} + +pub fn cmsgsteamdatagramconnectionstatsroutertoserver_unpack(buf []byte) ?CMsgSteamDatagramConnectionStatsRouterToServer { +mut res := CMsgSteamDatagramConnectionStatsRouterToServer{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_quality_relay = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionquality(cur_buf, tag_wiretype.wire_type)? +res.quality_relay = v +i = ii +} + +2 { +res.has_quality_e2e = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionquality(cur_buf, tag_wiretype.wire_type)? +res.quality_e2e = v +i = ii +} + +10 { +// [packed=false] +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.ack_relay << v +i = ii +} + +11 { +// [packed=false] +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.legacy_ack_e2e << v +i = ii +} + +12 { +res.has_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.flags = v +i = ii +} + +5 { +res.has_seq_num_r2s = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seq_num_r2s = v +i = ii +} + +6 { +res.has_seq_num_e2e = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seq_num_e2e = v +i = ii +} + +15 { +res.has_client_identity_string = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.client_identity_string = v +i = ii +} + +7 { +res.has_legacy_client_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.legacy_client_steam_id = v +i = ii +} + +8 { +res.has_relay_session_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.relay_session_id = v +i = ii +} + +9 { +res.has_client_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.client_connection_id = v +i = ii +} + +13 { +res.has_server_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.server_connection_id = v +i = ii +} + +14 { +res.has_routing_secret = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.routing_secret = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramconnectionstatsroutertoserver() CMsgSteamDatagramConnectionStatsRouterToServer { +return CMsgSteamDatagramConnectionStatsRouterToServer{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramconnectionstatsroutertoserver(o CMsgSteamDatagramConnectionStatsRouterToServer, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionstatsroutertoserver(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramConnectionStatsRouterToServer) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramconnectionstatsroutertoserver_unpack(v)? +return i, unpacked +} +[_allow_multiple_values] +enum CMsgSteamDatagramConnectionStatsServerToRouterFlags { +ack_request_relay = 1 +ack_request_e2e = 2 +ack_request_immediate = 4 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_cmsgsteamdatagramconnectionstatsservertorouterflags(e CMsgSteamDatagramConnectionStatsServerToRouterFlags, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionstatsservertorouterflags(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramConnectionStatsServerToRouterFlags) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, CMsgSteamDatagramConnectionStatsServerToRouterFlags(v) +} +pub struct CMsgSteamDatagramConnectionStatsServerToRouter { +mut: +unknown_fields []vproto.UnknownField +pub mut: +quality_relay CMsgSteamDatagramConnectionQuality +has_quality_relay bool +quality_e2e CMsgSteamDatagramConnectionQuality +has_quality_e2e bool +ack_relay []u32 +legacy_ack_e2e []u32 +flags u32 +has_flags bool +seq_num_s2r u32 +has_seq_num_s2r bool +seq_num_e2e u32 +has_seq_num_e2e bool +relay_session_id u32 +has_relay_session_id bool +client_connection_id u32 +has_client_connection_id bool +server_connection_id u32 +has_server_connection_id bool +} +pub fn (o &CMsgSteamDatagramConnectionStatsServerToRouter) pack() []byte { +mut res := []byte{} +if o.has_quality_relay { +res << zzz_vproto_internal_pack_cmsgsteamdatagramconnectionquality(o.quality_relay, 1) +} + +if o.has_quality_e2e { +res << zzz_vproto_internal_pack_cmsgsteamdatagramconnectionquality(o.quality_e2e, 2) +} + +// [packed=false] +for _, x in o.ack_relay { +res << vproto.pack_32bit_field(x, 8) +} + +// [packed=false] +for _, x in o.legacy_ack_e2e { +res << vproto.pack_32bit_field(x, 9) +} + +if o.has_flags { +res << vproto.pack_uint32_field(o.flags, 10) +} + +if o.has_seq_num_s2r { +res << vproto.pack_uint32_field(o.seq_num_s2r, 3) +} + +if o.has_seq_num_e2e { +res << vproto.pack_uint32_field(o.seq_num_e2e, 4) +} + +if o.has_relay_session_id { +res << vproto.pack_uint32_field(o.relay_session_id, 6) +} + +if o.has_client_connection_id { +res << vproto.pack_32bit_field(o.client_connection_id, 7) +} + +if o.has_server_connection_id { +res << vproto.pack_32bit_field(o.server_connection_id, 11) +} + +return res +} + +pub fn cmsgsteamdatagramconnectionstatsservertorouter_unpack(buf []byte) ?CMsgSteamDatagramConnectionStatsServerToRouter { +mut res := CMsgSteamDatagramConnectionStatsServerToRouter{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_quality_relay = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionquality(cur_buf, tag_wiretype.wire_type)? +res.quality_relay = v +i = ii +} + +2 { +res.has_quality_e2e = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionquality(cur_buf, tag_wiretype.wire_type)? +res.quality_e2e = v +i = ii +} + +8 { +// [packed=false] +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.ack_relay << v +i = ii +} + +9 { +// [packed=false] +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.legacy_ack_e2e << v +i = ii +} + +10 { +res.has_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.flags = v +i = ii +} + +3 { +res.has_seq_num_s2r = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seq_num_s2r = v +i = ii +} + +4 { +res.has_seq_num_e2e = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seq_num_e2e = v +i = ii +} + +6 { +res.has_relay_session_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.relay_session_id = v +i = ii +} + +7 { +res.has_client_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.client_connection_id = v +i = ii +} + +11 { +res.has_server_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.server_connection_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramconnectionstatsservertorouter() CMsgSteamDatagramConnectionStatsServerToRouter { +return CMsgSteamDatagramConnectionStatsServerToRouter{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramconnectionstatsservertorouter(o CMsgSteamDatagramConnectionStatsServerToRouter, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionstatsservertorouter(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramConnectionStatsServerToRouter) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramconnectionstatsservertorouter_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramP2PSessionRequestBody { +mut: +unknown_fields []vproto.UnknownField +pub mut: +challenge_time u32 +has_challenge_time bool +challenge u64 +has_challenge bool +client_connection_id u32 +has_client_connection_id bool +legacy_peer_steam_id u64 +has_legacy_peer_steam_id bool +peer_identity_string string +has_peer_identity_string bool +peer_connection_id u32 +has_peer_connection_id bool +protocol_version u32 +has_protocol_version bool +network_config_version u32 +has_network_config_version bool +public_ip u32 +has_public_ip bool +} +pub fn (o &CMsgSteamDatagramP2PSessionRequestBody) pack() []byte { +mut res := []byte{} +if o.has_challenge_time { +res << vproto.pack_32bit_field(o.challenge_time, 1) +} + +if o.has_challenge { +res << vproto.pack_64bit_field(o.challenge, 2) +} + +if o.has_client_connection_id { +res << vproto.pack_32bit_field(o.client_connection_id, 3) +} + +if o.has_legacy_peer_steam_id { +res << vproto.pack_64bit_field(o.legacy_peer_steam_id, 4) +} + +if o.has_peer_identity_string { +res << vproto.pack_string_field(o.peer_identity_string, 11) +} + +if o.has_peer_connection_id { +res << vproto.pack_32bit_field(o.peer_connection_id, 5) +} + +if o.has_protocol_version { +res << vproto.pack_uint32_field(o.protocol_version, 8) +} + +if o.has_network_config_version { +res << vproto.pack_uint32_field(o.network_config_version, 9) +} + +if o.has_public_ip { +res << vproto.pack_32bit_field(o.public_ip, 10) +} + +return res +} + +pub fn cmsgsteamdatagramp2psessionrequestbody_unpack(buf []byte) ?CMsgSteamDatagramP2PSessionRequestBody { +mut res := CMsgSteamDatagramP2PSessionRequestBody{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_challenge_time = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.challenge_time = v +i = ii +} + +2 { +res.has_challenge = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.challenge = v +i = ii +} + +3 { +res.has_client_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.client_connection_id = v +i = ii +} + +4 { +res.has_legacy_peer_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.legacy_peer_steam_id = v +i = ii +} + +11 { +res.has_peer_identity_string = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.peer_identity_string = v +i = ii +} + +5 { +res.has_peer_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.peer_connection_id = v +i = ii +} + +8 { +res.has_protocol_version = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.protocol_version = v +i = ii +} + +9 { +res.has_network_config_version = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.network_config_version = v +i = ii +} + +10 { +res.has_public_ip = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.public_ip = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramp2psessionrequestbody() CMsgSteamDatagramP2PSessionRequestBody { +return CMsgSteamDatagramP2PSessionRequestBody{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramp2psessionrequestbody(o CMsgSteamDatagramP2PSessionRequestBody, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramp2psessionrequestbody(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramP2PSessionRequestBody) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramp2psessionrequestbody_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramP2PSessionRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +cert CMsgSteamDatagramCertificateSigned +has_cert bool +body []byte +has_body bool +signature []byte +has_signature bool +} +pub fn (o &CMsgSteamDatagramP2PSessionRequest) pack() []byte { +mut res := []byte{} +if o.has_cert { +res << zzz_vproto_internal_pack_cmsgsteamdatagramcertificatesigned(o.cert, 1) +} + +if o.has_body { +res << vproto.pack_bytes_field(o.body, 2) +} + +if o.has_signature { +res << vproto.pack_bytes_field(o.signature, 3) +} + +return res +} + +pub fn cmsgsteamdatagramp2psessionrequest_unpack(buf []byte) ?CMsgSteamDatagramP2PSessionRequest { +mut res := CMsgSteamDatagramP2PSessionRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_cert = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramcertificatesigned(cur_buf, tag_wiretype.wire_type)? +res.cert = v +i = ii +} + +2 { +res.has_body = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.body = v +i = ii +} + +3 { +res.has_signature = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.signature = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramp2psessionrequest() CMsgSteamDatagramP2PSessionRequest { +return CMsgSteamDatagramP2PSessionRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramp2psessionrequest(o CMsgSteamDatagramP2PSessionRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramp2psessionrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramP2PSessionRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramp2psessionrequest_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramP2PSessionEstablished { +mut: +unknown_fields []vproto.UnknownField +pub mut: +connection_id u32 +has_connection_id bool +seconds_until_shutdown u32 +has_seconds_until_shutdown bool +relay_routing_token []byte +has_relay_routing_token bool +seq_num_r2c u32 +has_seq_num_r2c bool +} +pub fn (o &CMsgSteamDatagramP2PSessionEstablished) pack() []byte { +mut res := []byte{} +if o.has_connection_id { +res << vproto.pack_32bit_field(o.connection_id, 1) +} + +if o.has_seconds_until_shutdown { +res << vproto.pack_uint32_field(o.seconds_until_shutdown, 3) +} + +if o.has_relay_routing_token { +res << vproto.pack_bytes_field(o.relay_routing_token, 4) +} + +if o.has_seq_num_r2c { +res << vproto.pack_uint32_field(o.seq_num_r2c, 5) +} + +return res +} + +pub fn cmsgsteamdatagramp2psessionestablished_unpack(buf []byte) ?CMsgSteamDatagramP2PSessionEstablished { +mut res := CMsgSteamDatagramP2PSessionEstablished{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.connection_id = v +i = ii +} + +3 { +res.has_seconds_until_shutdown = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_until_shutdown = v +i = ii +} + +4 { +res.has_relay_routing_token = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.relay_routing_token = v +i = ii +} + +5 { +res.has_seq_num_r2c = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seq_num_r2c = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramp2psessionestablished() CMsgSteamDatagramP2PSessionEstablished { +return CMsgSteamDatagramP2PSessionEstablished{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramp2psessionestablished(o CMsgSteamDatagramP2PSessionEstablished, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramp2psessionestablished(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramP2PSessionEstablished) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramp2psessionestablished_unpack(v)? +return i, unpacked +} +[_allow_multiple_values] +enum CMsgSteamDatagramConnectionStatsP2PClientToRouterFlags { +ack_request_relay = 1 +ack_request_e2e = 2 +ack_request_immediate = 4 +not_primary_session = 8 +not_primary_transport_e2e = 16 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_cmsgsteamdatagramconnectionstatsp2pclienttorouterflags(e CMsgSteamDatagramConnectionStatsP2PClientToRouterFlags, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionstatsp2pclienttorouterflags(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramConnectionStatsP2PClientToRouterFlags) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, CMsgSteamDatagramConnectionStatsP2PClientToRouterFlags(v) +} +pub struct CMsgSteamDatagramConnectionStatsP2PClientToRouter { +mut: +unknown_fields []vproto.UnknownField +pub mut: +quality_relay CMsgSteamDatagramConnectionQuality +has_quality_relay bool +quality_e2e CMsgSteamDatagramConnectionQuality +has_quality_e2e bool +p2p_routing_summary CMsgSteamDatagramP2PRoutingSummary +has_p2p_routing_summary bool +ack_relay []u32 +legacy_ack_e2e []u32 +flags u32 +has_flags bool +forward_target_relay_routing_token []byte +has_forward_target_relay_routing_token bool +forward_target_revision u32 +has_forward_target_revision bool +routes []byte +has_routes bool +ack_peer_routes_revision u32 +has_ack_peer_routes_revision bool +connection_id u32 +has_connection_id bool +seq_num_c2r u32 +has_seq_num_c2r bool +seq_num_e2e u32 +has_seq_num_e2e bool +} +pub fn (o &CMsgSteamDatagramConnectionStatsP2PClientToRouter) pack() []byte { +mut res := []byte{} +if o.has_quality_relay { +res << zzz_vproto_internal_pack_cmsgsteamdatagramconnectionquality(o.quality_relay, 1) +} + +if o.has_quality_e2e { +res << zzz_vproto_internal_pack_cmsgsteamdatagramconnectionquality(o.quality_e2e, 2) +} + +if o.has_p2p_routing_summary { +res << zzz_vproto_internal_pack_cmsgsteamdatagramp2proutingsummary(o.p2p_routing_summary, 14) +} + +// [packed=false] +for _, x in o.ack_relay { +res << vproto.pack_32bit_field(x, 3) +} + +// [packed=false] +for _, x in o.legacy_ack_e2e { +res << vproto.pack_32bit_field(x, 4) +} + +if o.has_flags { +res << vproto.pack_uint32_field(o.flags, 5) +} + +if o.has_forward_target_relay_routing_token { +res << vproto.pack_bytes_field(o.forward_target_relay_routing_token, 6) +} + +if o.has_forward_target_revision { +res << vproto.pack_uint32_field(o.forward_target_revision, 7) +} + +if o.has_routes { +res << vproto.pack_bytes_field(o.routes, 8) +} + +if o.has_ack_peer_routes_revision { +res << vproto.pack_uint32_field(o.ack_peer_routes_revision, 9) +} + +if o.has_connection_id { +res << vproto.pack_32bit_field(o.connection_id, 10) +} + +if o.has_seq_num_c2r { +res << vproto.pack_uint32_field(o.seq_num_c2r, 11) +} + +if o.has_seq_num_e2e { +res << vproto.pack_uint32_field(o.seq_num_e2e, 12) +} + +return res +} + +pub fn cmsgsteamdatagramconnectionstatsp2pclienttorouter_unpack(buf []byte) ?CMsgSteamDatagramConnectionStatsP2PClientToRouter { +mut res := CMsgSteamDatagramConnectionStatsP2PClientToRouter{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_quality_relay = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionquality(cur_buf, tag_wiretype.wire_type)? +res.quality_relay = v +i = ii +} + +2 { +res.has_quality_e2e = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionquality(cur_buf, tag_wiretype.wire_type)? +res.quality_e2e = v +i = ii +} + +14 { +res.has_p2p_routing_summary = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramp2proutingsummary(cur_buf, tag_wiretype.wire_type)? +res.p2p_routing_summary = v +i = ii +} + +3 { +// [packed=false] +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.ack_relay << v +i = ii +} + +4 { +// [packed=false] +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.legacy_ack_e2e << v +i = ii +} + +5 { +res.has_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.flags = v +i = ii +} + +6 { +res.has_forward_target_relay_routing_token = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.forward_target_relay_routing_token = v +i = ii +} + +7 { +res.has_forward_target_revision = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.forward_target_revision = v +i = ii +} + +8 { +res.has_routes = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.routes = v +i = ii +} + +9 { +res.has_ack_peer_routes_revision = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ack_peer_routes_revision = v +i = ii +} + +10 { +res.has_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.connection_id = v +i = ii +} + +11 { +res.has_seq_num_c2r = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seq_num_c2r = v +i = ii +} + +12 { +res.has_seq_num_e2e = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seq_num_e2e = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramconnectionstatsp2pclienttorouter() CMsgSteamDatagramConnectionStatsP2PClientToRouter { +return CMsgSteamDatagramConnectionStatsP2PClientToRouter{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramconnectionstatsp2pclienttorouter(o CMsgSteamDatagramConnectionStatsP2PClientToRouter, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionstatsp2pclienttorouter(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramConnectionStatsP2PClientToRouter) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramconnectionstatsp2pclienttorouter_unpack(v)? +return i, unpacked +} +[_allow_multiple_values] +enum CMsgSteamDatagramConnectionStatsP2PRouterToClientFlags { +ack_request_relay = 1 +ack_request_e2e = 2 +ack_request_immediate = 4 +not_primary_transport_e2e = 16 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_cmsgsteamdatagramconnectionstatsp2proutertoclientflags(e CMsgSteamDatagramConnectionStatsP2PRouterToClientFlags, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionstatsp2proutertoclientflags(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramConnectionStatsP2PRouterToClientFlags) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, CMsgSteamDatagramConnectionStatsP2PRouterToClientFlags(v) +} +pub struct CMsgSteamDatagramConnectionStatsP2PRouterToClient { +mut: +unknown_fields []vproto.UnknownField +pub mut: +quality_relay CMsgSteamDatagramConnectionQuality +has_quality_relay bool +quality_e2e CMsgSteamDatagramConnectionQuality +has_quality_e2e bool +seconds_until_shutdown u32 +has_seconds_until_shutdown bool +migrate_request_ip u32 +has_migrate_request_ip bool +migrate_request_port u32 +has_migrate_request_port bool +scoring_penalty_relay_cluster u32 +has_scoring_penalty_relay_cluster bool +ack_relay []u32 +legacy_ack_e2e []u32 +flags u32 +has_flags bool +ack_forward_target_revision u32 +has_ack_forward_target_revision bool +routes []byte +has_routes bool +ack_peer_routes_revision u32 +has_ack_peer_routes_revision bool +connection_id u32 +has_connection_id bool +seq_num_r2c u32 +has_seq_num_r2c bool +seq_num_e2e u32 +has_seq_num_e2e bool +} +pub fn (o &CMsgSteamDatagramConnectionStatsP2PRouterToClient) pack() []byte { +mut res := []byte{} +if o.has_quality_relay { +res << zzz_vproto_internal_pack_cmsgsteamdatagramconnectionquality(o.quality_relay, 1) +} + +if o.has_quality_e2e { +res << zzz_vproto_internal_pack_cmsgsteamdatagramconnectionquality(o.quality_e2e, 2) +} + +if o.has_seconds_until_shutdown { +res << vproto.pack_uint32_field(o.seconds_until_shutdown, 3) +} + +if o.has_migrate_request_ip { +res << vproto.pack_32bit_field(o.migrate_request_ip, 4) +} + +if o.has_migrate_request_port { +res << vproto.pack_uint32_field(o.migrate_request_port, 5) +} + +if o.has_scoring_penalty_relay_cluster { +res << vproto.pack_uint32_field(o.scoring_penalty_relay_cluster, 6) +} + +// [packed=false] +for _, x in o.ack_relay { +res << vproto.pack_32bit_field(x, 7) +} + +// [packed=false] +for _, x in o.legacy_ack_e2e { +res << vproto.pack_32bit_field(x, 8) +} + +if o.has_flags { +res << vproto.pack_uint32_field(o.flags, 9) +} + +if o.has_ack_forward_target_revision { +res << vproto.pack_uint32_field(o.ack_forward_target_revision, 10) +} + +if o.has_routes { +res << vproto.pack_bytes_field(o.routes, 11) +} + +if o.has_ack_peer_routes_revision { +res << vproto.pack_uint32_field(o.ack_peer_routes_revision, 12) +} + +if o.has_connection_id { +res << vproto.pack_32bit_field(o.connection_id, 13) +} + +if o.has_seq_num_r2c { +res << vproto.pack_uint32_field(o.seq_num_r2c, 14) +} + +if o.has_seq_num_e2e { +res << vproto.pack_uint32_field(o.seq_num_e2e, 15) +} + +return res +} + +pub fn cmsgsteamdatagramconnectionstatsp2proutertoclient_unpack(buf []byte) ?CMsgSteamDatagramConnectionStatsP2PRouterToClient { +mut res := CMsgSteamDatagramConnectionStatsP2PRouterToClient{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_quality_relay = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionquality(cur_buf, tag_wiretype.wire_type)? +res.quality_relay = v +i = ii +} + +2 { +res.has_quality_e2e = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionquality(cur_buf, tag_wiretype.wire_type)? +res.quality_e2e = v +i = ii +} + +3 { +res.has_seconds_until_shutdown = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_until_shutdown = v +i = ii +} + +4 { +res.has_migrate_request_ip = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.migrate_request_ip = v +i = ii +} + +5 { +res.has_migrate_request_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.migrate_request_port = v +i = ii +} + +6 { +res.has_scoring_penalty_relay_cluster = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.scoring_penalty_relay_cluster = v +i = ii +} + +7 { +// [packed=false] +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.ack_relay << v +i = ii +} + +8 { +// [packed=false] +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.legacy_ack_e2e << v +i = ii +} + +9 { +res.has_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.flags = v +i = ii +} + +10 { +res.has_ack_forward_target_revision = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ack_forward_target_revision = v +i = ii +} + +11 { +res.has_routes = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.routes = v +i = ii +} + +12 { +res.has_ack_peer_routes_revision = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ack_peer_routes_revision = v +i = ii +} + +13 { +res.has_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.connection_id = v +i = ii +} + +14 { +res.has_seq_num_r2c = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seq_num_r2c = v +i = ii +} + +15 { +res.has_seq_num_e2e = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seq_num_e2e = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramconnectionstatsp2proutertoclient() CMsgSteamDatagramConnectionStatsP2PRouterToClient { +return CMsgSteamDatagramConnectionStatsP2PRouterToClient{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramconnectionstatsp2proutertoclient(o CMsgSteamDatagramConnectionStatsP2PRouterToClient, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionstatsp2proutertoclient(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramConnectionStatsP2PRouterToClient) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramconnectionstatsp2proutertoclient_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramP2PBadRouteRouterToClient { +mut: +unknown_fields []vproto.UnknownField +pub mut: +connection_id u32 +has_connection_id bool +failed_relay_routing_token []byte +has_failed_relay_routing_token bool +ack_forward_target_revision u32 +has_ack_forward_target_revision bool +kludge_pad u64 +has_kludge_pad bool +} +pub fn (o &CMsgSteamDatagramP2PBadRouteRouterToClient) pack() []byte { +mut res := []byte{} +if o.has_connection_id { +res << vproto.pack_32bit_field(o.connection_id, 1) +} + +if o.has_failed_relay_routing_token { +res << vproto.pack_bytes_field(o.failed_relay_routing_token, 2) +} + +if o.has_ack_forward_target_revision { +res << vproto.pack_uint32_field(o.ack_forward_target_revision, 3) +} + +if o.has_kludge_pad { +res << vproto.pack_64bit_field(o.kludge_pad, 99) +} + +return res +} + +pub fn cmsgsteamdatagramp2pbadrouteroutertoclient_unpack(buf []byte) ?CMsgSteamDatagramP2PBadRouteRouterToClient { +mut res := CMsgSteamDatagramP2PBadRouteRouterToClient{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.connection_id = v +i = ii +} + +2 { +res.has_failed_relay_routing_token = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.failed_relay_routing_token = v +i = ii +} + +3 { +res.has_ack_forward_target_revision = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ack_forward_target_revision = v +i = ii +} + +99 { +res.has_kludge_pad = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.kludge_pad = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramp2pbadrouteroutertoclient() CMsgSteamDatagramP2PBadRouteRouterToClient { +return CMsgSteamDatagramP2PBadRouteRouterToClient{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramp2pbadrouteroutertoclient(o CMsgSteamDatagramP2PBadRouteRouterToClient, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramp2pbadrouteroutertoclient(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramP2PBadRouteRouterToClient) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramp2pbadrouteroutertoclient_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramP2PRoutesRelayCluster { +mut: +unknown_fields []vproto.UnknownField +pub mut: +pop_id u32 +has_pop_id bool +ping_ms u32 +has_ping_ms bool +score_penalty u32 +has_score_penalty bool +session_relay_routing_token []byte +has_session_relay_routing_token bool +} +pub fn (o &CMsgSteamDatagramP2PRoutesRelayCluster) pack() []byte { +mut res := []byte{} +if o.has_pop_id { +res << vproto.pack_32bit_field(o.pop_id, 1) +} + +if o.has_ping_ms { +res << vproto.pack_uint32_field(o.ping_ms, 2) +} + +if o.has_score_penalty { +res << vproto.pack_uint32_field(o.score_penalty, 3) +} + +if o.has_session_relay_routing_token { +res << vproto.pack_bytes_field(o.session_relay_routing_token, 4) +} + +return res +} + +pub fn cmsgsteamdatagramp2proutesrelaycluster_unpack(buf []byte) ?CMsgSteamDatagramP2PRoutesRelayCluster { +mut res := CMsgSteamDatagramP2PRoutesRelayCluster{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_pop_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.pop_id = v +i = ii +} + +2 { +res.has_ping_ms = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ping_ms = v +i = ii +} + +3 { +res.has_score_penalty = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.score_penalty = v +i = ii +} + +4 { +res.has_session_relay_routing_token = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.session_relay_routing_token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramp2proutesrelaycluster() CMsgSteamDatagramP2PRoutesRelayCluster { +return CMsgSteamDatagramP2PRoutesRelayCluster{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramp2proutesrelaycluster(o CMsgSteamDatagramP2PRoutesRelayCluster, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramp2proutesrelaycluster(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramP2PRoutesRelayCluster) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramp2proutesrelaycluster_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramP2PRoutesRoute { +mut: +unknown_fields []vproto.UnknownField +pub mut: +my_pop_id u32 +has_my_pop_id bool +your_pop_id u32 +has_your_pop_id bool +score u32 +has_score bool +} +pub fn (o &CMsgSteamDatagramP2PRoutesRoute) pack() []byte { +mut res := []byte{} +if o.has_my_pop_id { +res << vproto.pack_32bit_field(o.my_pop_id, 1) +} + +if o.has_your_pop_id { +res << vproto.pack_32bit_field(o.your_pop_id, 2) +} + +if o.has_score { +res << vproto.pack_uint32_field(o.score, 3) +} + +return res +} + +pub fn cmsgsteamdatagramp2proutesroute_unpack(buf []byte) ?CMsgSteamDatagramP2PRoutesRoute { +mut res := CMsgSteamDatagramP2PRoutesRoute{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_my_pop_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.my_pop_id = v +i = ii +} + +2 { +res.has_your_pop_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.your_pop_id = v +i = ii +} + +3 { +res.has_score = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.score = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramp2proutesroute() CMsgSteamDatagramP2PRoutesRoute { +return CMsgSteamDatagramP2PRoutesRoute{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramp2proutesroute(o CMsgSteamDatagramP2PRoutesRoute, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramp2proutesroute(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramP2PRoutesRoute) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramp2proutesroute_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramP2PRoutes { +mut: +unknown_fields []vproto.UnknownField +pub mut: +relay_clusters []CMsgSteamDatagramP2PRoutesRelayCluster +routes []CMsgSteamDatagramP2PRoutesRoute +revision u32 +has_revision bool +} +pub fn (o &CMsgSteamDatagramP2PRoutes) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.relay_clusters { +res << zzz_vproto_internal_pack_cmsgsteamdatagramp2proutesrelaycluster(x, 1) +} + +// [packed=false] +for _, x in o.routes { +res << zzz_vproto_internal_pack_cmsgsteamdatagramp2proutesroute(x, 2) +} + +if o.has_revision { +res << vproto.pack_uint32_field(o.revision, 3) +} + +return res +} + +pub fn cmsgsteamdatagramp2proutes_unpack(buf []byte) ?CMsgSteamDatagramP2PRoutes { +mut res := CMsgSteamDatagramP2PRoutes{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramp2proutesrelaycluster(cur_buf, tag_wiretype.wire_type)? +res.relay_clusters << v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramp2proutesroute(cur_buf, tag_wiretype.wire_type)? +res.routes << v +i = ii +} + +3 { +res.has_revision = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.revision = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramp2proutes() CMsgSteamDatagramP2PRoutes { +return CMsgSteamDatagramP2PRoutes{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramp2proutes(o CMsgSteamDatagramP2PRoutes, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramp2proutes(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramP2PRoutes) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramp2proutes_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramGameServerSample { +mut: +unknown_fields []vproto.UnknownField +pub mut: +ipv4 u32 +has_ipv4 bool +port u32 +has_port bool +} +pub fn (o &CMsgSteamDatagramGameServerSample) pack() []byte { +mut res := []byte{} +if o.has_ipv4 { +res << vproto.pack_32bit_field(o.ipv4, 1) +} + +if o.has_port { +res << vproto.pack_uint32_field(o.port, 2) +} + +return res +} + +pub fn cmsgsteamdatagramgameserversample_unpack(buf []byte) ?CMsgSteamDatagramGameServerSample { +mut res := CMsgSteamDatagramGameServerSample{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_ipv4 = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.ipv4 = v +i = ii +} + +2 { +res.has_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.port = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramgameserversample() CMsgSteamDatagramGameServerSample { +return CMsgSteamDatagramGameServerSample{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramgameserversample(o CMsgSteamDatagramGameServerSample, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramgameserversample(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramGameServerSample) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramgameserversample_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramGameServerSampleDataCenter { +mut: +unknown_fields []vproto.UnknownField +pub mut: +datacenter_id u32 +has_datacenter_id bool +servers []CMsgSteamDatagramGameServerSample +} +pub fn (o &CMsgSteamDatagramGameServerSampleDataCenter) pack() []byte { +mut res := []byte{} +if o.has_datacenter_id { +res << vproto.pack_32bit_field(o.datacenter_id, 1) +} + +// [packed=false] +for _, x in o.servers { +res << zzz_vproto_internal_pack_cmsgsteamdatagramgameserversample(x, 3) +} + +return res +} + +pub fn cmsgsteamdatagramgameserversampledatacenter_unpack(buf []byte) ?CMsgSteamDatagramGameServerSampleDataCenter { +mut res := CMsgSteamDatagramGameServerSampleDataCenter{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_datacenter_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.datacenter_id = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramgameserversample(cur_buf, tag_wiretype.wire_type)? +res.servers << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramgameserversampledatacenter() CMsgSteamDatagramGameServerSampleDataCenter { +return CMsgSteamDatagramGameServerSampleDataCenter{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramgameserversampledatacenter(o CMsgSteamDatagramGameServerSampleDataCenter, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramgameserversampledatacenter(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramGameServerSampleDataCenter) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramgameserversampledatacenter_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramRelayToRelayPing { +mut: +unknown_fields []vproto.UnknownField +pub mut: +request_timestamp u32 +has_request_timestamp bool +request_date u32 +has_request_date bool +my_pop_id u32 +has_my_pop_id bool +your_pop_id u32 +has_your_pop_id bool +checksum u32 +has_checksum bool +data_centers []CMsgSteamDatagramGameServerSampleDataCenter +} +pub fn (o &CMsgSteamDatagramRelayToRelayPing) pack() []byte { +mut res := []byte{} +if o.has_request_timestamp { +res << vproto.pack_32bit_field(o.request_timestamp, 1) +} + +if o.has_request_date { +res << vproto.pack_32bit_field(o.request_date, 2) +} + +if o.has_my_pop_id { +res << vproto.pack_32bit_field(o.my_pop_id, 3) +} + +if o.has_your_pop_id { +res << vproto.pack_32bit_field(o.your_pop_id, 4) +} + +if o.has_checksum { +res << vproto.pack_32bit_field(o.checksum, 5) +} + +// [packed=false] +for _, x in o.data_centers { +res << zzz_vproto_internal_pack_cmsgsteamdatagramgameserversampledatacenter(x, 6) +} + +return res +} + +pub fn cmsgsteamdatagramrelaytorelayping_unpack(buf []byte) ?CMsgSteamDatagramRelayToRelayPing { +mut res := CMsgSteamDatagramRelayToRelayPing{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_request_timestamp = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.request_timestamp = v +i = ii +} + +2 { +res.has_request_date = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.request_date = v +i = ii +} + +3 { +res.has_my_pop_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.my_pop_id = v +i = ii +} + +4 { +res.has_your_pop_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.your_pop_id = v +i = ii +} + +5 { +res.has_checksum = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.checksum = v +i = ii +} + +6 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramgameserversampledatacenter(cur_buf, tag_wiretype.wire_type)? +res.data_centers << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramrelaytorelayping() CMsgSteamDatagramRelayToRelayPing { +return CMsgSteamDatagramRelayToRelayPing{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramrelaytorelayping(o CMsgSteamDatagramRelayToRelayPing, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramrelaytorelayping(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramRelayToRelayPing) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramrelaytorelayping_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramDataCenterStateServer { +mut: +unknown_fields []vproto.UnknownField +pub mut: +address string +has_address bool +ping_ms u32 +has_ping_ms bool +} +pub fn (o &CMsgSteamDatagramDataCenterStateServer) pack() []byte { +mut res := []byte{} +if o.has_address { +res << vproto.pack_string_field(o.address, 1) +} + +if o.has_ping_ms { +res << vproto.pack_uint32_field(o.ping_ms, 2) +} + +return res +} + +pub fn cmsgsteamdatagramdatacenterstateserver_unpack(buf []byte) ?CMsgSteamDatagramDataCenterStateServer { +mut res := CMsgSteamDatagramDataCenterStateServer{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_address = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.address = v +i = ii +} + +2 { +res.has_ping_ms = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ping_ms = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramdatacenterstateserver() CMsgSteamDatagramDataCenterStateServer { +return CMsgSteamDatagramDataCenterStateServer{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramdatacenterstateserver(o CMsgSteamDatagramDataCenterStateServer, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramdatacenterstateserver(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramDataCenterStateServer) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramdatacenterstateserver_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramDataCenterStateDataCenter { +mut: +unknown_fields []vproto.UnknownField +pub mut: +code string +has_code bool +server_sample []CMsgSteamDatagramDataCenterStateServer +relay_sample []CMsgSteamDatagramDataCenterStateServer +} +pub fn (o &CMsgSteamDatagramDataCenterStateDataCenter) pack() []byte { +mut res := []byte{} +if o.has_code { +res << vproto.pack_string_field(o.code, 1) +} + +// [packed=false] +for _, x in o.server_sample { +res << zzz_vproto_internal_pack_cmsgsteamdatagramdatacenterstateserver(x, 2) +} + +// [packed=false] +for _, x in o.relay_sample { +res << zzz_vproto_internal_pack_cmsgsteamdatagramdatacenterstateserver(x, 3) +} + +return res +} + +pub fn cmsgsteamdatagramdatacenterstatedatacenter_unpack(buf []byte) ?CMsgSteamDatagramDataCenterStateDataCenter { +mut res := CMsgSteamDatagramDataCenterStateDataCenter{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.code = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramdatacenterstateserver(cur_buf, tag_wiretype.wire_type)? +res.server_sample << v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramdatacenterstateserver(cur_buf, tag_wiretype.wire_type)? +res.relay_sample << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramdatacenterstatedatacenter() CMsgSteamDatagramDataCenterStateDataCenter { +return CMsgSteamDatagramDataCenterStateDataCenter{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramdatacenterstatedatacenter(o CMsgSteamDatagramDataCenterStateDataCenter, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramdatacenterstatedatacenter(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramDataCenterStateDataCenter) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramdatacenterstatedatacenter_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramDataCenterState { +mut: +unknown_fields []vproto.UnknownField +pub mut: +data_centers []CMsgSteamDatagramDataCenterStateDataCenter +} +pub fn (o &CMsgSteamDatagramDataCenterState) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.data_centers { +res << zzz_vproto_internal_pack_cmsgsteamdatagramdatacenterstatedatacenter(x, 1) +} + +return res +} + +pub fn cmsgsteamdatagramdatacenterstate_unpack(buf []byte) ?CMsgSteamDatagramDataCenterState { +mut res := CMsgSteamDatagramDataCenterState{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramdatacenterstatedatacenter(cur_buf, tag_wiretype.wire_type)? +res.data_centers << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramdatacenterstate() CMsgSteamDatagramDataCenterState { +return CMsgSteamDatagramDataCenterState{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramdatacenterstate(o CMsgSteamDatagramDataCenterState, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramdatacenterstate(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramDataCenterState) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramdatacenterstate_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramRouterHealthDataCenter { +mut: +unknown_fields []vproto.UnknownField +pub mut: +datacenter_id u32 +has_datacenter_id bool +state u32 +has_state bool +servers []CMsgSteamDatagramGameServerSample +} +pub fn (o &CMsgSteamDatagramRouterHealthDataCenter) pack() []byte { +mut res := []byte{} +if o.has_datacenter_id { +res << vproto.pack_32bit_field(o.datacenter_id, 1) +} + +if o.has_state { +res << vproto.pack_uint32_field(o.state, 2) +} + +// [packed=false] +for _, x in o.servers { +res << zzz_vproto_internal_pack_cmsgsteamdatagramgameserversample(x, 3) +} + +return res +} + +pub fn cmsgsteamdatagramrouterhealthdatacenter_unpack(buf []byte) ?CMsgSteamDatagramRouterHealthDataCenter { +mut res := CMsgSteamDatagramRouterHealthDataCenter{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_datacenter_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.datacenter_id = v +i = ii +} + +2 { +res.has_state = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.state = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramgameserversample(cur_buf, tag_wiretype.wire_type)? +res.servers << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramrouterhealthdatacenter() CMsgSteamDatagramRouterHealthDataCenter { +return CMsgSteamDatagramRouterHealthDataCenter{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramrouterhealthdatacenter(o CMsgSteamDatagramRouterHealthDataCenter, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramrouterhealthdatacenter(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramRouterHealthDataCenter) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramrouterhealthdatacenter_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramRouterHealth { +mut: +unknown_fields []vproto.UnknownField +pub mut: +cpu_load f32 +has_cpu_load bool +cpu_load_raw f32 +has_cpu_load_raw bool +active_sessions u32 +has_active_sessions bool +data_pkts_sec u32 +has_data_pkts_sec bool +other_pkts_sec u32 +has_other_pkts_sec bool +seconds_until_shutdown u32 +has_seconds_until_shutdown bool +cpu_cost_per_user f32 +has_cpu_cost_per_user bool +cpu_cost_per_packet f32 +has_cpu_cost_per_packet bool +data_centers []CMsgSteamDatagramRouterHealthDataCenter +magic u64 +has_magic bool +} +pub fn (o &CMsgSteamDatagramRouterHealth) pack() []byte { +mut res := []byte{} +if o.has_cpu_load { +res << vproto.pack_float_field(o.cpu_load, 1) +} + +if o.has_cpu_load_raw { +res << vproto.pack_float_field(o.cpu_load_raw, 10) +} + +if o.has_active_sessions { +res << vproto.pack_uint32_field(o.active_sessions, 2) +} + +if o.has_data_pkts_sec { +res << vproto.pack_uint32_field(o.data_pkts_sec, 3) +} + +if o.has_other_pkts_sec { +res << vproto.pack_uint32_field(o.other_pkts_sec, 4) +} + +if o.has_seconds_until_shutdown { +res << vproto.pack_uint32_field(o.seconds_until_shutdown, 5) +} + +if o.has_cpu_cost_per_user { +res << vproto.pack_float_field(o.cpu_cost_per_user, 8) +} + +if o.has_cpu_cost_per_packet { +res << vproto.pack_float_field(o.cpu_cost_per_packet, 9) +} + +// [packed=false] +for _, x in o.data_centers { +res << zzz_vproto_internal_pack_cmsgsteamdatagramrouterhealthdatacenter(x, 6) +} + +if o.has_magic { +res << vproto.pack_64bit_field(o.magic, 7) +} + +return res +} + +pub fn cmsgsteamdatagramrouterhealth_unpack(buf []byte) ?CMsgSteamDatagramRouterHealth { +mut res := CMsgSteamDatagramRouterHealth{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_cpu_load = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.cpu_load = v +i = ii +} + +10 { +res.has_cpu_load_raw = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.cpu_load_raw = v +i = ii +} + +2 { +res.has_active_sessions = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.active_sessions = v +i = ii +} + +3 { +res.has_data_pkts_sec = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.data_pkts_sec = v +i = ii +} + +4 { +res.has_other_pkts_sec = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.other_pkts_sec = v +i = ii +} + +5 { +res.has_seconds_until_shutdown = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_until_shutdown = v +i = ii +} + +8 { +res.has_cpu_cost_per_user = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.cpu_cost_per_user = v +i = ii +} + +9 { +res.has_cpu_cost_per_packet = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.cpu_cost_per_packet = v +i = ii +} + +6 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramrouterhealthdatacenter(cur_buf, tag_wiretype.wire_type)? +res.data_centers << v +i = ii +} + +7 { +res.has_magic = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.magic = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramrouterhealth() CMsgSteamDatagramRouterHealth { +return CMsgSteamDatagramRouterHealth{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramrouterhealth(o CMsgSteamDatagramRouterHealth, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramrouterhealth(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramRouterHealth) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramrouterhealth_unpack(v)? +return i, unpacked +} +[_allow_multiple_values] +enum CMsgSteamDatagramConnectionStatsP2PRouterToRouterFlags { +ack_request_relay = 1 +ack_request_e2e = 2 +ack_request_immediate = 4 +not_primary_transport_e2e = 16 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_cmsgsteamdatagramconnectionstatsp2proutertorouterflags(e CMsgSteamDatagramConnectionStatsP2PRouterToRouterFlags, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionstatsp2proutertorouterflags(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramConnectionStatsP2PRouterToRouterFlags) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, CMsgSteamDatagramConnectionStatsP2PRouterToRouterFlags(v) +} +pub struct CMsgSteamDatagramConnectionStatsP2PRouterToRouter { +mut: +unknown_fields []vproto.UnknownField +pub mut: +quality_relay CMsgSteamDatagramConnectionQuality +has_quality_relay bool +quality_e2e CMsgSteamDatagramConnectionQuality +has_quality_e2e bool +ack_relay []u32 +legacy_ack_e2e []u32 +flags u32 +has_flags bool +ack_forward_target_revision u32 +has_ack_forward_target_revision bool +routes []byte +has_routes bool +ack_peer_routes_revision u32 +has_ack_peer_routes_revision bool +seq_num_r2r u32 +has_seq_num_r2r bool +seq_num_e2e u32 +has_seq_num_e2e bool +from_relay_session_id u32 +has_from_relay_session_id bool +to_relay_session_id u32 +has_to_relay_session_id bool +} +pub fn (o &CMsgSteamDatagramConnectionStatsP2PRouterToRouter) pack() []byte { +mut res := []byte{} +if o.has_quality_relay { +res << zzz_vproto_internal_pack_cmsgsteamdatagramconnectionquality(o.quality_relay, 1) +} + +if o.has_quality_e2e { +res << zzz_vproto_internal_pack_cmsgsteamdatagramconnectionquality(o.quality_e2e, 2) +} + +// [packed=false] +for _, x in o.ack_relay { +res << vproto.pack_32bit_field(x, 3) +} + +// [packed=false] +for _, x in o.legacy_ack_e2e { +res << vproto.pack_32bit_field(x, 4) +} + +if o.has_flags { +res << vproto.pack_uint32_field(o.flags, 5) +} + +if o.has_ack_forward_target_revision { +res << vproto.pack_uint32_field(o.ack_forward_target_revision, 6) +} + +if o.has_routes { +res << vproto.pack_bytes_field(o.routes, 7) +} + +if o.has_ack_peer_routes_revision { +res << vproto.pack_uint32_field(o.ack_peer_routes_revision, 8) +} + +if o.has_seq_num_r2r { +res << vproto.pack_uint32_field(o.seq_num_r2r, 26) +} + +if o.has_seq_num_e2e { +res << vproto.pack_uint32_field(o.seq_num_e2e, 27) +} + +if o.has_from_relay_session_id { +res << vproto.pack_32bit_field(o.from_relay_session_id, 22) +} + +if o.has_to_relay_session_id { +res << vproto.pack_32bit_field(o.to_relay_session_id, 25) +} + +return res +} + +pub fn cmsgsteamdatagramconnectionstatsp2proutertorouter_unpack(buf []byte) ?CMsgSteamDatagramConnectionStatsP2PRouterToRouter { +mut res := CMsgSteamDatagramConnectionStatsP2PRouterToRouter{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_quality_relay = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionquality(cur_buf, tag_wiretype.wire_type)? +res.quality_relay = v +i = ii +} + +2 { +res.has_quality_e2e = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionquality(cur_buf, tag_wiretype.wire_type)? +res.quality_e2e = v +i = ii +} + +3 { +// [packed=false] +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.ack_relay << v +i = ii +} + +4 { +// [packed=false] +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.legacy_ack_e2e << v +i = ii +} + +5 { +res.has_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.flags = v +i = ii +} + +6 { +res.has_ack_forward_target_revision = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ack_forward_target_revision = v +i = ii +} + +7 { +res.has_routes = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.routes = v +i = ii +} + +8 { +res.has_ack_peer_routes_revision = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ack_peer_routes_revision = v +i = ii +} + +26 { +res.has_seq_num_r2r = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seq_num_r2r = v +i = ii +} + +27 { +res.has_seq_num_e2e = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seq_num_e2e = v +i = ii +} + +22 { +res.has_from_relay_session_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.from_relay_session_id = v +i = ii +} + +25 { +res.has_to_relay_session_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.to_relay_session_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramconnectionstatsp2proutertorouter() CMsgSteamDatagramConnectionStatsP2PRouterToRouter { +return CMsgSteamDatagramConnectionStatsP2PRouterToRouter{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramconnectionstatsp2proutertorouter(o CMsgSteamDatagramConnectionStatsP2PRouterToRouter, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionstatsp2proutertorouter(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramConnectionStatsP2PRouterToRouter) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramconnectionstatsp2proutertorouter_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_accounthardware.steamclient_pb.v b/proto/steammessages_accounthardware.steamclient_pb.v new file mode 100644 index 0000000..ece68ce --- /dev/null +++ b/proto/steammessages_accounthardware.steamclient_pb.v @@ -0,0 +1,1793 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +[_allow_multiple_values] +enum EValveIndexComponent { +k_evalveindexcomponentunknown = 0 +k_evalveindexcomponenthmd = 1 +k_evalveindexcomponentleftknuckle = 2 +k_evalveindexcomponentrightknuckle = 3 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_evalveindexcomponent(e EValveIndexComponent, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_evalveindexcomponent(buf []byte, tag_wiretype vproto.WireType) ?(int, EValveIndexComponent) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EValveIndexComponent(v) +} +pub struct CAccountHardwareRegisterSteamControllerRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +serial_number string +has_serial_number bool +controller_code string +has_controller_code bool +} +pub fn (o &CAccountHardwareRegisterSteamControllerRequest) pack() []byte { +mut res := []byte{} +if o.has_serial_number { +res << vproto.pack_string_field(o.serial_number, 1) +} + +if o.has_controller_code { +res << vproto.pack_string_field(o.controller_code, 2) +} + +return res +} + +pub fn caccounthardwareregistersteamcontrollerrequest_unpack(buf []byte) ?CAccountHardwareRegisterSteamControllerRequest { +mut res := CAccountHardwareRegisterSteamControllerRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_serial_number = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.serial_number = v +i = ii +} + +2 { +res.has_controller_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.controller_code = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccounthardwareregistersteamcontrollerrequest() CAccountHardwareRegisterSteamControllerRequest { +return CAccountHardwareRegisterSteamControllerRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccounthardwareregistersteamcontrollerrequest(o CAccountHardwareRegisterSteamControllerRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccounthardwareregistersteamcontrollerrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountHardwareRegisterSteamControllerRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccounthardwareregistersteamcontrollerrequest_unpack(v)? +return i, unpacked +} +pub struct CAccountHardwareRegisterSteamControllerResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CAccountHardwareRegisterSteamControllerResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn caccounthardwareregistersteamcontrollerresponse_unpack(buf []byte) ?CAccountHardwareRegisterSteamControllerResponse { +res := CAccountHardwareRegisterSteamControllerResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccounthardwareregistersteamcontrollerresponse() CAccountHardwareRegisterSteamControllerResponse { +return CAccountHardwareRegisterSteamControllerResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccounthardwareregistersteamcontrollerresponse(o CAccountHardwareRegisterSteamControllerResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccounthardwareregistersteamcontrollerresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountHardwareRegisterSteamControllerResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccounthardwareregistersteamcontrollerresponse_unpack(v)? +return i, unpacked +} +pub struct CAccountHardwareCompleteSteamControllerRegistrationRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +serial_number string +has_serial_number bool +controller_code string +has_controller_code bool +} +pub fn (o &CAccountHardwareCompleteSteamControllerRegistrationRequest) pack() []byte { +mut res := []byte{} +if o.has_serial_number { +res << vproto.pack_string_field(o.serial_number, 1) +} + +if o.has_controller_code { +res << vproto.pack_string_field(o.controller_code, 2) +} + +return res +} + +pub fn caccounthardwarecompletesteamcontrollerregistrationrequest_unpack(buf []byte) ?CAccountHardwareCompleteSteamControllerRegistrationRequest { +mut res := CAccountHardwareCompleteSteamControllerRegistrationRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_serial_number = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.serial_number = v +i = ii +} + +2 { +res.has_controller_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.controller_code = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccounthardwarecompletesteamcontrollerregistrationrequest() CAccountHardwareCompleteSteamControllerRegistrationRequest { +return CAccountHardwareCompleteSteamControllerRegistrationRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccounthardwarecompletesteamcontrollerregistrationrequest(o CAccountHardwareCompleteSteamControllerRegistrationRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccounthardwarecompletesteamcontrollerregistrationrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountHardwareCompleteSteamControllerRegistrationRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccounthardwarecompletesteamcontrollerregistrationrequest_unpack(v)? +return i, unpacked +} +pub struct CAccountHardwareCompleteSteamControllerRegistrationResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CAccountHardwareCompleteSteamControllerRegistrationResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn caccounthardwarecompletesteamcontrollerregistrationresponse_unpack(buf []byte) ?CAccountHardwareCompleteSteamControllerRegistrationResponse { +res := CAccountHardwareCompleteSteamControllerRegistrationResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccounthardwarecompletesteamcontrollerregistrationresponse() CAccountHardwareCompleteSteamControllerRegistrationResponse { +return CAccountHardwareCompleteSteamControllerRegistrationResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccounthardwarecompletesteamcontrollerregistrationresponse(o CAccountHardwareCompleteSteamControllerRegistrationResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccounthardwarecompletesteamcontrollerregistrationresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountHardwareCompleteSteamControllerRegistrationResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccounthardwarecompletesteamcontrollerregistrationresponse_unpack(v)? +return i, unpacked +} +pub struct CAccountHardwareQueryAccountsRegisteredToSerialRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +serial_number string +has_serial_number bool +controller_code string +has_controller_code bool +} +pub fn (o &CAccountHardwareQueryAccountsRegisteredToSerialRequest) pack() []byte { +mut res := []byte{} +if o.has_serial_number { +res << vproto.pack_string_field(o.serial_number, 1) +} + +if o.has_controller_code { +res << vproto.pack_string_field(o.controller_code, 2) +} + +return res +} + +pub fn caccounthardwarequeryaccountsregisteredtoserialrequest_unpack(buf []byte) ?CAccountHardwareQueryAccountsRegisteredToSerialRequest { +mut res := CAccountHardwareQueryAccountsRegisteredToSerialRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_serial_number = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.serial_number = v +i = ii +} + +2 { +res.has_controller_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.controller_code = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccounthardwarequeryaccountsregisteredtoserialrequest() CAccountHardwareQueryAccountsRegisteredToSerialRequest { +return CAccountHardwareQueryAccountsRegisteredToSerialRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccounthardwarequeryaccountsregisteredtoserialrequest(o CAccountHardwareQueryAccountsRegisteredToSerialRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccounthardwarequeryaccountsregisteredtoserialrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountHardwareQueryAccountsRegisteredToSerialRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccounthardwarequeryaccountsregisteredtoserialrequest_unpack(v)? +return i, unpacked +} +pub struct CAccountHardwareQueryAccountsRegisteredToSerialAccounts { +mut: +unknown_fields []vproto.UnknownField +pub mut: +accountid u32 +has_accountid bool +registration_complete bool +has_registration_complete bool +} +pub fn (o &CAccountHardwareQueryAccountsRegisteredToSerialAccounts) pack() []byte { +mut res := []byte{} +if o.has_accountid { +res << vproto.pack_uint32_field(o.accountid, 1) +} + +if o.has_registration_complete { +res << vproto.pack_bool_field(o.registration_complete, 2) +} + +return res +} + +pub fn caccounthardwarequeryaccountsregisteredtoserialaccounts_unpack(buf []byte) ?CAccountHardwareQueryAccountsRegisteredToSerialAccounts { +mut res := CAccountHardwareQueryAccountsRegisteredToSerialAccounts{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_accountid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.accountid = v +i = ii +} + +2 { +res.has_registration_complete = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.registration_complete = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccounthardwarequeryaccountsregisteredtoserialaccounts() CAccountHardwareQueryAccountsRegisteredToSerialAccounts { +return CAccountHardwareQueryAccountsRegisteredToSerialAccounts{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccounthardwarequeryaccountsregisteredtoserialaccounts(o CAccountHardwareQueryAccountsRegisteredToSerialAccounts, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccounthardwarequeryaccountsregisteredtoserialaccounts(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountHardwareQueryAccountsRegisteredToSerialAccounts) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccounthardwarequeryaccountsregisteredtoserialaccounts_unpack(v)? +return i, unpacked +} +pub struct CAccountHardwareQueryAccountsRegisteredToSerialResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +accounts []CAccountHardwareQueryAccountsRegisteredToSerialAccounts +} +pub fn (o &CAccountHardwareQueryAccountsRegisteredToSerialResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.accounts { +res << zzz_vproto_internal_pack_caccounthardwarequeryaccountsregisteredtoserialaccounts(x, 1) +} + +return res +} + +pub fn caccounthardwarequeryaccountsregisteredtoserialresponse_unpack(buf []byte) ?CAccountHardwareQueryAccountsRegisteredToSerialResponse { +mut res := CAccountHardwareQueryAccountsRegisteredToSerialResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_caccounthardwarequeryaccountsregisteredtoserialaccounts(cur_buf, tag_wiretype.wire_type)? +res.accounts << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccounthardwarequeryaccountsregisteredtoserialresponse() CAccountHardwareQueryAccountsRegisteredToSerialResponse { +return CAccountHardwareQueryAccountsRegisteredToSerialResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccounthardwarequeryaccountsregisteredtoserialresponse(o CAccountHardwareQueryAccountsRegisteredToSerialResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccounthardwarequeryaccountsregisteredtoserialresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountHardwareQueryAccountsRegisteredToSerialResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccounthardwarequeryaccountsregisteredtoserialresponse_unpack(v)? +return i, unpacked +} +pub struct CAccountHardwareSteamControllerSetConfigControllerConfig { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appidorname string +has_appidorname bool +publishedfileid u64 +has_publishedfileid bool +templatename string +has_templatename bool +} +pub fn (o &CAccountHardwareSteamControllerSetConfigControllerConfig) pack() []byte { +mut res := []byte{} +if o.has_appidorname { +res << vproto.pack_string_field(o.appidorname, 1) +} + +if o.has_publishedfileid { +res << vproto.pack_uint64_field(o.publishedfileid, 2) +} + +if o.has_templatename { +res << vproto.pack_string_field(o.templatename, 3) +} + +return res +} + +pub fn caccounthardwaresteamcontrollersetconfigcontrollerconfig_unpack(buf []byte) ?CAccountHardwareSteamControllerSetConfigControllerConfig { +mut res := CAccountHardwareSteamControllerSetConfigControllerConfig{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appidorname = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.appidorname = v +i = ii +} + +2 { +res.has_publishedfileid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.publishedfileid = v +i = ii +} + +3 { +res.has_templatename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.templatename = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccounthardwaresteamcontrollersetconfigcontrollerconfig() CAccountHardwareSteamControllerSetConfigControllerConfig { +return CAccountHardwareSteamControllerSetConfigControllerConfig{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccounthardwaresteamcontrollersetconfigcontrollerconfig(o CAccountHardwareSteamControllerSetConfigControllerConfig, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccounthardwaresteamcontrollersetconfigcontrollerconfig(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountHardwareSteamControllerSetConfigControllerConfig) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccounthardwaresteamcontrollersetconfigcontrollerconfig_unpack(v)? +return i, unpacked +} +pub struct CAccountHardwareSteamControllerSetConfigRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +serial_number string +has_serial_number bool +controller_code string +has_controller_code bool +accountid u32 +has_accountid bool +configurations []CAccountHardwareSteamControllerSetConfigControllerConfig +controller_type int +has_controller_type bool +only_for_this_serial bool +has_only_for_this_serial bool +} +pub fn (o &CAccountHardwareSteamControllerSetConfigRequest) pack() []byte { +mut res := []byte{} +if o.has_serial_number { +res << vproto.pack_string_field(o.serial_number, 1) +} + +if o.has_controller_code { +res << vproto.pack_string_field(o.controller_code, 2) +} + +if o.has_accountid { +res << vproto.pack_uint32_field(o.accountid, 3) +} + +// [packed=false] +for _, x in o.configurations { +res << zzz_vproto_internal_pack_caccounthardwaresteamcontrollersetconfigcontrollerconfig(x, 4) +} + +if o.has_controller_type { +res << vproto.pack_int32_field(o.controller_type, 5) +} + +if o.has_only_for_this_serial { +res << vproto.pack_bool_field(o.only_for_this_serial, 6) +} + +return res +} + +pub fn caccounthardwaresteamcontrollersetconfigrequest_unpack(buf []byte) ?CAccountHardwareSteamControllerSetConfigRequest { +mut res := CAccountHardwareSteamControllerSetConfigRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_serial_number = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.serial_number = v +i = ii +} + +2 { +res.has_controller_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.controller_code = v +i = ii +} + +3 { +res.has_accountid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.accountid = v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_caccounthardwaresteamcontrollersetconfigcontrollerconfig(cur_buf, tag_wiretype.wire_type)? +res.configurations << v +i = ii +} + +5 { +res.has_controller_type = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.controller_type = v +i = ii +} + +6 { +res.has_only_for_this_serial = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.only_for_this_serial = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccounthardwaresteamcontrollersetconfigrequest() CAccountHardwareSteamControllerSetConfigRequest { +return CAccountHardwareSteamControllerSetConfigRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccounthardwaresteamcontrollersetconfigrequest(o CAccountHardwareSteamControllerSetConfigRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccounthardwaresteamcontrollersetconfigrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountHardwareSteamControllerSetConfigRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccounthardwaresteamcontrollersetconfigrequest_unpack(v)? +return i, unpacked +} +pub struct CAccountHardwareSteamControllerSetConfigResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CAccountHardwareSteamControllerSetConfigResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn caccounthardwaresteamcontrollersetconfigresponse_unpack(buf []byte) ?CAccountHardwareSteamControllerSetConfigResponse { +res := CAccountHardwareSteamControllerSetConfigResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccounthardwaresteamcontrollersetconfigresponse() CAccountHardwareSteamControllerSetConfigResponse { +return CAccountHardwareSteamControllerSetConfigResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccounthardwaresteamcontrollersetconfigresponse(o CAccountHardwareSteamControllerSetConfigResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccounthardwaresteamcontrollersetconfigresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountHardwareSteamControllerSetConfigResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccounthardwaresteamcontrollersetconfigresponse_unpack(v)? +return i, unpacked +} +pub struct CAccountHardwareSteamControllerGetConfigRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +serial_number string +has_serial_number bool +controller_code string +has_controller_code bool +accountid u32 +has_accountid bool +appidorname string +has_appidorname bool +controller_type int +has_controller_type bool +only_for_this_serial bool +has_only_for_this_serial bool +} +pub fn (o &CAccountHardwareSteamControllerGetConfigRequest) pack() []byte { +mut res := []byte{} +if o.has_serial_number { +res << vproto.pack_string_field(o.serial_number, 1) +} + +if o.has_controller_code { +res << vproto.pack_string_field(o.controller_code, 2) +} + +if o.has_accountid { +res << vproto.pack_uint32_field(o.accountid, 3) +} + +if o.has_appidorname { +res << vproto.pack_string_field(o.appidorname, 4) +} + +if o.has_controller_type { +res << vproto.pack_int32_field(o.controller_type, 5) +} + +if o.has_only_for_this_serial { +res << vproto.pack_bool_field(o.only_for_this_serial, 6) +} + +return res +} + +pub fn caccounthardwaresteamcontrollergetconfigrequest_unpack(buf []byte) ?CAccountHardwareSteamControllerGetConfigRequest { +mut res := CAccountHardwareSteamControllerGetConfigRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_serial_number = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.serial_number = v +i = ii +} + +2 { +res.has_controller_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.controller_code = v +i = ii +} + +3 { +res.has_accountid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.accountid = v +i = ii +} + +4 { +res.has_appidorname = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.appidorname = v +i = ii +} + +5 { +res.has_controller_type = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.controller_type = v +i = ii +} + +6 { +res.has_only_for_this_serial = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.only_for_this_serial = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccounthardwaresteamcontrollergetconfigrequest() CAccountHardwareSteamControllerGetConfigRequest { +return CAccountHardwareSteamControllerGetConfigRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccounthardwaresteamcontrollergetconfigrequest(o CAccountHardwareSteamControllerGetConfigRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccounthardwaresteamcontrollergetconfigrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountHardwareSteamControllerGetConfigRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccounthardwaresteamcontrollergetconfigrequest_unpack(v)? +return i, unpacked +} +pub struct CAccountHardwareSteamControllerGetConfigControllerConfig { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appidorname string +has_appidorname bool +publishedfileid u64 +has_publishedfileid bool +templatename string +has_templatename bool +serial_number string +has_serial_number bool +} +pub fn (o &CAccountHardwareSteamControllerGetConfigControllerConfig) pack() []byte { +mut res := []byte{} +if o.has_appidorname { +res << vproto.pack_string_field(o.appidorname, 1) +} + +if o.has_publishedfileid { +res << vproto.pack_uint64_field(o.publishedfileid, 2) +} + +if o.has_templatename { +res << vproto.pack_string_field(o.templatename, 3) +} + +if o.has_serial_number { +res << vproto.pack_string_field(o.serial_number, 4) +} + +return res +} + +pub fn caccounthardwaresteamcontrollergetconfigcontrollerconfig_unpack(buf []byte) ?CAccountHardwareSteamControllerGetConfigControllerConfig { +mut res := CAccountHardwareSteamControllerGetConfigControllerConfig{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appidorname = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.appidorname = v +i = ii +} + +2 { +res.has_publishedfileid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.publishedfileid = v +i = ii +} + +3 { +res.has_templatename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.templatename = v +i = ii +} + +4 { +res.has_serial_number = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.serial_number = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccounthardwaresteamcontrollergetconfigcontrollerconfig() CAccountHardwareSteamControllerGetConfigControllerConfig { +return CAccountHardwareSteamControllerGetConfigControllerConfig{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccounthardwaresteamcontrollergetconfigcontrollerconfig(o CAccountHardwareSteamControllerGetConfigControllerConfig, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccounthardwaresteamcontrollergetconfigcontrollerconfig(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountHardwareSteamControllerGetConfigControllerConfig) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccounthardwaresteamcontrollergetconfigcontrollerconfig_unpack(v)? +return i, unpacked +} +pub struct CAccountHardwareSteamControllerGetConfigResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +configurations []CAccountHardwareSteamControllerGetConfigControllerConfig +} +pub fn (o &CAccountHardwareSteamControllerGetConfigResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.configurations { +res << zzz_vproto_internal_pack_caccounthardwaresteamcontrollergetconfigcontrollerconfig(x, 1) +} + +return res +} + +pub fn caccounthardwaresteamcontrollergetconfigresponse_unpack(buf []byte) ?CAccountHardwareSteamControllerGetConfigResponse { +mut res := CAccountHardwareSteamControllerGetConfigResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_caccounthardwaresteamcontrollergetconfigcontrollerconfig(cur_buf, tag_wiretype.wire_type)? +res.configurations << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccounthardwaresteamcontrollergetconfigresponse() CAccountHardwareSteamControllerGetConfigResponse { +return CAccountHardwareSteamControllerGetConfigResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccounthardwaresteamcontrollergetconfigresponse(o CAccountHardwareSteamControllerGetConfigResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccounthardwaresteamcontrollergetconfigresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountHardwareSteamControllerGetConfigResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccounthardwaresteamcontrollergetconfigresponse_unpack(v)? +return i, unpacked +} +pub struct CAccountHardwareDeRegisterSteamControllerRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +serial_number string +has_serial_number bool +controller_code string +has_controller_code bool +accountid u32 +has_accountid bool +} +pub fn (o &CAccountHardwareDeRegisterSteamControllerRequest) pack() []byte { +mut res := []byte{} +if o.has_serial_number { +res << vproto.pack_string_field(o.serial_number, 1) +} + +if o.has_controller_code { +res << vproto.pack_string_field(o.controller_code, 2) +} + +if o.has_accountid { +res << vproto.pack_uint32_field(o.accountid, 3) +} + +return res +} + +pub fn caccounthardwarederegistersteamcontrollerrequest_unpack(buf []byte) ?CAccountHardwareDeRegisterSteamControllerRequest { +mut res := CAccountHardwareDeRegisterSteamControllerRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_serial_number = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.serial_number = v +i = ii +} + +2 { +res.has_controller_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.controller_code = v +i = ii +} + +3 { +res.has_accountid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.accountid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccounthardwarederegistersteamcontrollerrequest() CAccountHardwareDeRegisterSteamControllerRequest { +return CAccountHardwareDeRegisterSteamControllerRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccounthardwarederegistersteamcontrollerrequest(o CAccountHardwareDeRegisterSteamControllerRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccounthardwarederegistersteamcontrollerrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountHardwareDeRegisterSteamControllerRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccounthardwarederegistersteamcontrollerrequest_unpack(v)? +return i, unpacked +} +pub struct CAccountHardwareDeRegisterSteamControllerResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CAccountHardwareDeRegisterSteamControllerResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn caccounthardwarederegistersteamcontrollerresponse_unpack(buf []byte) ?CAccountHardwareDeRegisterSteamControllerResponse { +res := CAccountHardwareDeRegisterSteamControllerResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccounthardwarederegistersteamcontrollerresponse() CAccountHardwareDeRegisterSteamControllerResponse { +return CAccountHardwareDeRegisterSteamControllerResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccounthardwarederegistersteamcontrollerresponse(o CAccountHardwareDeRegisterSteamControllerResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccounthardwarederegistersteamcontrollerresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountHardwareDeRegisterSteamControllerResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccounthardwarederegistersteamcontrollerresponse_unpack(v)? +return i, unpacked +} +pub struct CAccountHardwareSetPersonalizationFileRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +serial_number string +has_serial_number bool +publishedfileid u64 +has_publishedfileid bool +accountid u32 +has_accountid bool +} +pub fn (o &CAccountHardwareSetPersonalizationFileRequest) pack() []byte { +mut res := []byte{} +if o.has_serial_number { +res << vproto.pack_string_field(o.serial_number, 1) +} + +if o.has_publishedfileid { +res << vproto.pack_uint64_field(o.publishedfileid, 2) +} + +if o.has_accountid { +res << vproto.pack_uint32_field(o.accountid, 3) +} + +return res +} + +pub fn caccounthardwaresetpersonalizationfilerequest_unpack(buf []byte) ?CAccountHardwareSetPersonalizationFileRequest { +mut res := CAccountHardwareSetPersonalizationFileRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_serial_number = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.serial_number = v +i = ii +} + +2 { +res.has_publishedfileid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.publishedfileid = v +i = ii +} + +3 { +res.has_accountid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.accountid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccounthardwaresetpersonalizationfilerequest() CAccountHardwareSetPersonalizationFileRequest { +return CAccountHardwareSetPersonalizationFileRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccounthardwaresetpersonalizationfilerequest(o CAccountHardwareSetPersonalizationFileRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccounthardwaresetpersonalizationfilerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountHardwareSetPersonalizationFileRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccounthardwaresetpersonalizationfilerequest_unpack(v)? +return i, unpacked +} +pub struct CAccountHardwareSetPersonalizationFileResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CAccountHardwareSetPersonalizationFileResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn caccounthardwaresetpersonalizationfileresponse_unpack(buf []byte) ?CAccountHardwareSetPersonalizationFileResponse { +res := CAccountHardwareSetPersonalizationFileResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccounthardwaresetpersonalizationfileresponse() CAccountHardwareSetPersonalizationFileResponse { +return CAccountHardwareSetPersonalizationFileResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccounthardwaresetpersonalizationfileresponse(o CAccountHardwareSetPersonalizationFileResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccounthardwaresetpersonalizationfileresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountHardwareSetPersonalizationFileResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccounthardwaresetpersonalizationfileresponse_unpack(v)? +return i, unpacked +} +pub struct CAccountHardwareGetPersonalizationFileRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +serial_number string +has_serial_number bool +accountid u32 +has_accountid bool +} +pub fn (o &CAccountHardwareGetPersonalizationFileRequest) pack() []byte { +mut res := []byte{} +if o.has_serial_number { +res << vproto.pack_string_field(o.serial_number, 1) +} + +if o.has_accountid { +res << vproto.pack_uint32_field(o.accountid, 2) +} + +return res +} + +pub fn caccounthardwaregetpersonalizationfilerequest_unpack(buf []byte) ?CAccountHardwareGetPersonalizationFileRequest { +mut res := CAccountHardwareGetPersonalizationFileRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_serial_number = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.serial_number = v +i = ii +} + +2 { +res.has_accountid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.accountid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccounthardwaregetpersonalizationfilerequest() CAccountHardwareGetPersonalizationFileRequest { +return CAccountHardwareGetPersonalizationFileRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccounthardwaregetpersonalizationfilerequest(o CAccountHardwareGetPersonalizationFileRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccounthardwaregetpersonalizationfilerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountHardwareGetPersonalizationFileRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccounthardwaregetpersonalizationfilerequest_unpack(v)? +return i, unpacked +} +pub struct CAccountHardwareGetPersonalizationFileResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +publishedfileid u64 +has_publishedfileid bool +} +pub fn (o &CAccountHardwareGetPersonalizationFileResponse) pack() []byte { +mut res := []byte{} +if o.has_publishedfileid { +res << vproto.pack_uint64_field(o.publishedfileid, 1) +} + +return res +} + +pub fn caccounthardwaregetpersonalizationfileresponse_unpack(buf []byte) ?CAccountHardwareGetPersonalizationFileResponse { +mut res := CAccountHardwareGetPersonalizationFileResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_publishedfileid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.publishedfileid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccounthardwaregetpersonalizationfileresponse() CAccountHardwareGetPersonalizationFileResponse { +return CAccountHardwareGetPersonalizationFileResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccounthardwaregetpersonalizationfileresponse(o CAccountHardwareGetPersonalizationFileResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccounthardwaregetpersonalizationfileresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountHardwareGetPersonalizationFileResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccounthardwaregetpersonalizationfileresponse_unpack(v)? +return i, unpacked +} +pub struct CAccountHardwareVRcompatibilityCheckRequestPair { +mut: +unknown_fields []vproto.UnknownField +pub mut: +key string +has_key bool +value string +has_value bool +} +pub fn (o &CAccountHardwareVRcompatibilityCheckRequestPair) pack() []byte { +mut res := []byte{} +if o.has_key { +res << vproto.pack_string_field(o.key, 1) +} + +if o.has_value { +res << vproto.pack_string_field(o.value, 2) +} + +return res +} + +pub fn caccounthardwarevrcompatibilitycheckrequestpair_unpack(buf []byte) ?CAccountHardwareVRcompatibilityCheckRequestPair { +mut res := CAccountHardwareVRcompatibilityCheckRequestPair{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_key = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.key = v +i = ii +} + +2 { +res.has_value = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.value = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccounthardwarevrcompatibilitycheckrequestpair() CAccountHardwareVRcompatibilityCheckRequestPair { +return CAccountHardwareVRcompatibilityCheckRequestPair{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccounthardwarevrcompatibilitycheckrequestpair(o CAccountHardwareVRcompatibilityCheckRequestPair, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccounthardwarevrcompatibilitycheckrequestpair(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountHardwareVRcompatibilityCheckRequestPair) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccounthardwarevrcompatibilitycheckrequestpair_unpack(v)? +return i, unpacked +} +pub struct CAccountHardwareVRcompatibilityCheckRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +product_name string +has_product_name bool +values []CAccountHardwareVRcompatibilityCheckRequestPair +} +pub fn (o &CAccountHardwareVRcompatibilityCheckRequest) pack() []byte { +mut res := []byte{} +if o.has_product_name { +res << vproto.pack_string_field(o.product_name, 1) +} + +// [packed=false] +for _, x in o.values { +res << zzz_vproto_internal_pack_caccounthardwarevrcompatibilitycheckrequestpair(x, 2) +} + +return res +} + +pub fn caccounthardwarevrcompatibilitycheckrequest_unpack(buf []byte) ?CAccountHardwareVRcompatibilityCheckRequest { +mut res := CAccountHardwareVRcompatibilityCheckRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_product_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.product_name = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_caccounthardwarevrcompatibilitycheckrequestpair(cur_buf, tag_wiretype.wire_type)? +res.values << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccounthardwarevrcompatibilitycheckrequest() CAccountHardwareVRcompatibilityCheckRequest { +return CAccountHardwareVRcompatibilityCheckRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccounthardwarevrcompatibilitycheckrequest(o CAccountHardwareVRcompatibilityCheckRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccounthardwarevrcompatibilitycheckrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountHardwareVRcompatibilityCheckRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccounthardwarevrcompatibilitycheckrequest_unpack(v)? +return i, unpacked +} +pub struct CAccountHardwareVRcompatibilityCheckResponsePair { +mut: +unknown_fields []vproto.UnknownField +pub mut: +key string +has_key bool +value string +has_value bool +} +pub fn (o &CAccountHardwareVRcompatibilityCheckResponsePair) pack() []byte { +mut res := []byte{} +if o.has_key { +res << vproto.pack_string_field(o.key, 1) +} + +if o.has_value { +res << vproto.pack_string_field(o.value, 2) +} + +return res +} + +pub fn caccounthardwarevrcompatibilitycheckresponsepair_unpack(buf []byte) ?CAccountHardwareVRcompatibilityCheckResponsePair { +mut res := CAccountHardwareVRcompatibilityCheckResponsePair{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_key = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.key = v +i = ii +} + +2 { +res.has_value = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.value = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccounthardwarevrcompatibilitycheckresponsepair() CAccountHardwareVRcompatibilityCheckResponsePair { +return CAccountHardwareVRcompatibilityCheckResponsePair{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccounthardwarevrcompatibilitycheckresponsepair(o CAccountHardwareVRcompatibilityCheckResponsePair, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccounthardwarevrcompatibilitycheckresponsepair(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountHardwareVRcompatibilityCheckResponsePair) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccounthardwarevrcompatibilitycheckresponsepair_unpack(v)? +return i, unpacked +} +pub struct CAccountHardwareVRcompatibilityCheckResponseComponentDisplay { +mut: +unknown_fields []vproto.UnknownField +pub mut: +name string +has_name bool +image string +has_image bool +value string +has_value bool +} +pub fn (o &CAccountHardwareVRcompatibilityCheckResponseComponentDisplay) pack() []byte { +mut res := []byte{} +if o.has_name { +res << vproto.pack_string_field(o.name, 1) +} + +if o.has_image { +res << vproto.pack_string_field(o.image, 2) +} + +if o.has_value { +res << vproto.pack_string_field(o.value, 3) +} + +return res +} + +pub fn caccounthardwarevrcompatibilitycheckresponsecomponentdisplay_unpack(buf []byte) ?CAccountHardwareVRcompatibilityCheckResponseComponentDisplay { +mut res := CAccountHardwareVRcompatibilityCheckResponseComponentDisplay{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +2 { +res.has_image = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.image = v +i = ii +} + +3 { +res.has_value = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.value = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccounthardwarevrcompatibilitycheckresponsecomponentdisplay() CAccountHardwareVRcompatibilityCheckResponseComponentDisplay { +return CAccountHardwareVRcompatibilityCheckResponseComponentDisplay{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccounthardwarevrcompatibilitycheckresponsecomponentdisplay(o CAccountHardwareVRcompatibilityCheckResponseComponentDisplay, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccounthardwarevrcompatibilitycheckresponsecomponentdisplay(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountHardwareVRcompatibilityCheckResponseComponentDisplay) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccounthardwarevrcompatibilitycheckresponsecomponentdisplay_unpack(v)? +return i, unpacked +} +pub struct CAccountHardwareVRcompatibilityCheckResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +values []CAccountHardwareVRcompatibilityCheckResponsePair +components []CAccountHardwareVRcompatibilityCheckResponseComponentDisplay +} +pub fn (o &CAccountHardwareVRcompatibilityCheckResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.values { +res << zzz_vproto_internal_pack_caccounthardwarevrcompatibilitycheckresponsepair(x, 1) +} + +// [packed=false] +for _, x in o.components { +res << zzz_vproto_internal_pack_caccounthardwarevrcompatibilitycheckresponsecomponentdisplay(x, 2) +} + +return res +} + +pub fn caccounthardwarevrcompatibilitycheckresponse_unpack(buf []byte) ?CAccountHardwareVRcompatibilityCheckResponse { +mut res := CAccountHardwareVRcompatibilityCheckResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_caccounthardwarevrcompatibilitycheckresponsepair(cur_buf, tag_wiretype.wire_type)? +res.values << v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_caccounthardwarevrcompatibilitycheckresponsecomponentdisplay(cur_buf, tag_wiretype.wire_type)? +res.components << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccounthardwarevrcompatibilitycheckresponse() CAccountHardwareVRcompatibilityCheckResponse { +return CAccountHardwareVRcompatibilityCheckResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccounthardwarevrcompatibilitycheckresponse(o CAccountHardwareVRcompatibilityCheckResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccounthardwarevrcompatibilitycheckresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountHardwareVRcompatibilityCheckResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccounthardwarevrcompatibilitycheckresponse_unpack(v)? +return i, unpacked +} +pub struct CAccountHardwareRegisterValveIndexComponentRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +serial_number string +has_serial_number bool +manufacturer_serial_number string +has_manufacturer_serial_number bool +component_code string +has_component_code bool +component_type EValveIndexComponent +has_component_type bool +estimated_time_registered int +has_estimated_time_registered bool +} +pub fn (o &CAccountHardwareRegisterValveIndexComponentRequest) pack() []byte { +mut res := []byte{} +if o.has_serial_number { +res << vproto.pack_string_field(o.serial_number, 1) +} + +if o.has_manufacturer_serial_number { +res << vproto.pack_string_field(o.manufacturer_serial_number, 2) +} + +if o.has_component_code { +res << vproto.pack_string_field(o.component_code, 3) +} + +if o.has_component_type { +res << zzz_vproto_internal_pack_evalveindexcomponent(o.component_type, 4) +} + +if o.has_estimated_time_registered { +res << vproto.pack_int32_field(o.estimated_time_registered, 5) +} + +return res +} + +pub fn caccounthardwareregistervalveindexcomponentrequest_unpack(buf []byte) ?CAccountHardwareRegisterValveIndexComponentRequest { +mut res := CAccountHardwareRegisterValveIndexComponentRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_serial_number = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.serial_number = v +i = ii +} + +2 { +res.has_manufacturer_serial_number = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.manufacturer_serial_number = v +i = ii +} + +3 { +res.has_component_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.component_code = v +i = ii +} + +4 { +res.has_component_type = true +ii, v := zzz_vproto_internal_unpack_evalveindexcomponent(cur_buf, tag_wiretype.wire_type)? +res.component_type = v +i = ii +} + +5 { +res.has_estimated_time_registered = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.estimated_time_registered = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccounthardwareregistervalveindexcomponentrequest() CAccountHardwareRegisterValveIndexComponentRequest { +return CAccountHardwareRegisterValveIndexComponentRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccounthardwareregistervalveindexcomponentrequest(o CAccountHardwareRegisterValveIndexComponentRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccounthardwareregistervalveindexcomponentrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountHardwareRegisterValveIndexComponentRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccounthardwareregistervalveindexcomponentrequest_unpack(v)? +return i, unpacked +} +pub struct CAccountHardwareRegisterValveIndexComponentResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CAccountHardwareRegisterValveIndexComponentResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn caccounthardwareregistervalveindexcomponentresponse_unpack(buf []byte) ?CAccountHardwareRegisterValveIndexComponentResponse { +res := CAccountHardwareRegisterValveIndexComponentResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccounthardwareregistervalveindexcomponentresponse() CAccountHardwareRegisterValveIndexComponentResponse { +return CAccountHardwareRegisterValveIndexComponentResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccounthardwareregistervalveindexcomponentresponse(o CAccountHardwareRegisterValveIndexComponentResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccounthardwareregistervalveindexcomponentresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountHardwareRegisterValveIndexComponentResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccounthardwareregistervalveindexcomponentresponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_appoverview_pb.v b/proto/steammessages_appoverview_pb.v new file mode 100644 index 0000000..68a8b65 --- /dev/null +++ b/proto/steammessages_appoverview_pb.v @@ -0,0 +1,1176 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +[_allow_multiple_values] +enum EDisplayStatus { +k_edisplaystatusinvalid = 0 +k_edisplaystatuslaunching = 1 +k_edisplaystatusuninstalling = 2 +k_edisplaystatusinstalling = 3 +k_edisplaystatusrunning = 4 +k_edisplaystatusvalidating = 5 +k_edisplaystatusupdating = 6 +k_edisplaystatusdownloading = 7 +k_edisplaystatussynchronizing = 8 +k_edisplaystatusreadytoinstall = 9 +k_edisplaystatusreadytopreload = 10 +k_edisplaystatusreadytolaunch = 11 +k_edisplaystatusregionrestricted = 12 +k_edisplaystatuspresaleonly = 13 +k_edisplaystatusinvalidplatform = 14 +k_edisplaystatuspreloadcomplete = 16 +k_edisplaystatusborrowerlocked = 17 +k_edisplaystatusupdatepaused = 18 +k_edisplaystatusupdatequeued = 19 +k_edisplaystatusupdaterequired = 20 +k_edisplaystatusupdatedisabled = 21 +k_edisplaystatusdownloadpaused = 22 +k_edisplaystatusdownloadqueued = 23 +k_edisplaystatusdownloadrequired = 24 +k_edisplaystatusdownloaddisabled = 25 +k_edisplaystatuslicensepending = 26 +k_edisplaystatuslicenseexpired = 27 +k_edisplaystatusavailforfree = 28 +k_edisplaystatusavailtoborrow = 29 +k_edisplaystatusavailguestpass = 30 +k_edisplaystatuspurchase = 31 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_edisplaystatus(e EDisplayStatus, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_edisplaystatus(buf []byte, tag_wiretype vproto.WireType) ?(int, EDisplayStatus) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EDisplayStatus(v) +} +[_allow_multiple_values] +enum EProtoAppType { +k_eapptypeinvalid = 0 +k_eapptypegame = 1 +k_eapptypeapplication = 2 +k_eapptypetool = 4 +k_eapptypedemo = 8 +k_eapptypedeprected = 16 +k_eapptypedlc = 32 +k_eapptypeguide = 64 +k_eapptypedriver = 128 +k_eapptypeconfig = 256 +k_eapptypehardware = 512 +k_eapptypefranchise = 1024 +k_eapptypevideo = 2048 +k_eapptypeplugin = 4096 +k_eapptypemusicalbum = 8192 +k_eapptypeseries = 16384 +k_eapptypecomic = 32768 +k_eapptypebeta = 65536 +k_eapptypeshortcut = 1073741824 +k_eapptypedepotonly = -2147483648 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_eprotoapptype(e EProtoAppType, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_eprotoapptype(buf []byte, tag_wiretype vproto.WireType) ?(int, EProtoAppType) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EProtoAppType(v) +} +[_allow_multiple_values] +enum EAppAssociationType { +k_eappassociationtypeinvalid = 0 +k_eappassociationtypepublisher = 1 +k_eappassociationtypedeveloper = 2 +k_eappassociationtypefranchise = 3 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_eappassociationtype(e EAppAssociationType, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_eappassociationtype(buf []byte, tag_wiretype vproto.WireType) ?(int, EAppAssociationType) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EAppAssociationType(v) +} +[_allow_multiple_values] +enum EAppControllerSupportLevel { +k_eappcontrollersupportlevelnone = 0 +k_eappcontrollersupportlevelpartial = 1 +k_eappcontrollersupportlevelfull = 2 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_eappcontrollersupportlevel(e EAppControllerSupportLevel, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_eappcontrollersupportlevel(buf []byte, tag_wiretype vproto.WireType) ?(int, EAppControllerSupportLevel) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EAppControllerSupportLevel(v) +} +pub struct CAppOverviewAppAssociation { +mut: +unknown_fields []vproto.UnknownField +pub mut: +@type EAppAssociationType +has_type bool +name string +has_name bool +} +pub fn (o &CAppOverviewAppAssociation) pack() []byte { +mut res := []byte{} +if o.has_type { +res << zzz_vproto_internal_pack_eappassociationtype(o.@type, 1) +} + +if o.has_name { +res << vproto.pack_string_field(o.name, 2) +} + +return res +} + +pub fn cappoverviewappassociation_unpack(buf []byte) ?CAppOverviewAppAssociation { +mut res := CAppOverviewAppAssociation{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_type = true +ii, v := zzz_vproto_internal_unpack_eappassociationtype(cur_buf, tag_wiretype.wire_type)? +res.@type = v +i = ii +} + +2 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cappoverviewappassociation() CAppOverviewAppAssociation { +return CAppOverviewAppAssociation{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cappoverviewappassociation(o CAppOverviewAppAssociation, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cappoverviewappassociation(buf []byte, tag_wiretype vproto.WireType) ?(int, CAppOverviewAppAssociation) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cappoverviewappassociation_unpack(v)? +return i, unpacked +} +pub struct CAppOverviewPerClientData { +mut: +unknown_fields []vproto.UnknownField +pub mut: +clientid u64 +has_clientid bool +client_name string +has_client_name bool +display_status EDisplayStatus +has_display_status bool +status_percentage u32 +has_status_percentage bool +active_beta string +has_active_beta bool +installed bool +has_installed bool +bytes_downloaded u64 +has_bytes_downloaded bool +bytes_total u64 +has_bytes_total bool +streaming_to_local_client bool +has_streaming_to_local_client bool +is_available_on_current_platform bool +has_is_available_on_current_platform bool +is_invalid_os_type bool +has_is_invalid_os_type bool +playtime_left u32 +has_playtime_left bool +} +pub fn (o &CAppOverviewPerClientData) pack() []byte { +mut res := []byte{} +if o.has_clientid { +res << vproto.pack_uint64_field(o.clientid, 1) +} + +if o.has_client_name { +res << vproto.pack_string_field(o.client_name, 2) +} + +if o.has_display_status { +res << zzz_vproto_internal_pack_edisplaystatus(o.display_status, 3) +} + +if o.has_status_percentage { +res << vproto.pack_uint32_field(o.status_percentage, 4) +} + +if o.has_active_beta { +res << vproto.pack_string_field(o.active_beta, 5) +} + +if o.has_installed { +res << vproto.pack_bool_field(o.installed, 6) +} + +if o.has_bytes_downloaded { +res << vproto.pack_uint64_field(o.bytes_downloaded, 7) +} + +if o.has_bytes_total { +res << vproto.pack_uint64_field(o.bytes_total, 8) +} + +if o.has_streaming_to_local_client { +res << vproto.pack_bool_field(o.streaming_to_local_client, 9) +} + +if o.has_is_available_on_current_platform { +res << vproto.pack_bool_field(o.is_available_on_current_platform, 10) +} + +if o.has_is_invalid_os_type { +res << vproto.pack_bool_field(o.is_invalid_os_type, 11) +} + +if o.has_playtime_left { +res << vproto.pack_uint32_field(o.playtime_left, 12) +} + +return res +} + +pub fn cappoverviewperclientdata_unpack(buf []byte) ?CAppOverviewPerClientData { +mut res := CAppOverviewPerClientData{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_clientid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.clientid = v +i = ii +} + +2 { +res.has_client_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.client_name = v +i = ii +} + +3 { +res.has_display_status = true +ii, v := zzz_vproto_internal_unpack_edisplaystatus(cur_buf, tag_wiretype.wire_type)? +res.display_status = v +i = ii +} + +4 { +res.has_status_percentage = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.status_percentage = v +i = ii +} + +5 { +res.has_active_beta = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.active_beta = v +i = ii +} + +6 { +res.has_installed = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.installed = v +i = ii +} + +7 { +res.has_bytes_downloaded = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.bytes_downloaded = v +i = ii +} + +8 { +res.has_bytes_total = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.bytes_total = v +i = ii +} + +9 { +res.has_streaming_to_local_client = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.streaming_to_local_client = v +i = ii +} + +10 { +res.has_is_available_on_current_platform = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_available_on_current_platform = v +i = ii +} + +11 { +res.has_is_invalid_os_type = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_invalid_os_type = v +i = ii +} + +12 { +res.has_playtime_left = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.playtime_left = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cappoverviewperclientdata() CAppOverviewPerClientData { +return CAppOverviewPerClientData{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cappoverviewperclientdata(o CAppOverviewPerClientData, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cappoverviewperclientdata(buf []byte, tag_wiretype vproto.WireType) ?(int, CAppOverviewPerClientData) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cappoverviewperclientdata_unpack(v)? +return i, unpacked +} +pub struct CAppOverview { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +display_name string +has_display_name bool +visible_in_game_list bool +has_visible_in_game_list bool +sort_as string +has_sort_as bool +app_type EProtoAppType +has_app_type bool +mru_index u32 +has_mru_index bool +rt_recent_activity_time u32 +has_rt_recent_activity_time bool +minutes_playtime_forever u32 +has_minutes_playtime_forever bool +minutes_playtime_last_two_weeks u32 +has_minutes_playtime_last_two_weeks bool +rt_last_time_played u32 +has_rt_last_time_played bool +store_tag []u32 +association []CAppOverviewAppAssociation +store_category []u32 +rt_original_release_date u32 +has_rt_original_release_date bool +rt_steam_release_date u32 +has_rt_steam_release_date bool +icon_hash string +has_icon_hash bool +logo_hash string +has_logo_hash bool +controller_support EAppControllerSupportLevel +has_controller_support bool +vr_supported bool +has_vr_supported bool +metacritic_score u32 +has_metacritic_score bool +size_on_disk u64 +has_size_on_disk bool +third_party_mod bool +has_third_party_mod bool +icon_data string +has_icon_data bool +icon_data_format string +has_icon_data_format bool +gameid string +has_gameid bool +library_capsule_filename string +has_library_capsule_filename bool +per_client_data []CAppOverviewPerClientData +most_available_clientid u64 +has_most_available_clientid bool +selected_clientid u64 +has_selected_clientid bool +rt_store_asset_mtime u32 +has_rt_store_asset_mtime bool +rt_custom_image_mtime u32 +has_rt_custom_image_mtime bool +optional_parent_app_id u32 +has_optional_parent_app_id bool +owner_account_id u32 +has_owner_account_id bool +compat_mapping_enabled bool +has_compat_mapping_enabled bool +compat_mapping_priority u32 +has_compat_mapping_priority bool +compat_mapping_tool_name string +has_compat_mapping_tool_name bool +review_score_with_bombs u32 +has_review_score_with_bombs bool +review_percentage_with_bombs u32 +has_review_percentage_with_bombs bool +review_score_without_bombs u32 +has_review_score_without_bombs bool +review_percentage_without_bombs u32 +has_review_percentage_without_bombs bool +library_id string +has_library_id bool +} +pub fn (o &CAppOverview) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_display_name { +res << vproto.pack_string_field(o.display_name, 2) +} + +if o.has_visible_in_game_list { +res << vproto.pack_bool_field(o.visible_in_game_list, 4) +} + +if o.has_sort_as { +res << vproto.pack_string_field(o.sort_as, 6) +} + +if o.has_app_type { +res << zzz_vproto_internal_pack_eprotoapptype(o.app_type, 7) +} + +if o.has_mru_index { +res << vproto.pack_uint32_field(o.mru_index, 13) +} + +if o.has_rt_recent_activity_time { +res << vproto.pack_uint32_field(o.rt_recent_activity_time, 14) +} + +if o.has_minutes_playtime_forever { +res << vproto.pack_uint32_field(o.minutes_playtime_forever, 16) +} + +if o.has_minutes_playtime_last_two_weeks { +res << vproto.pack_uint32_field(o.minutes_playtime_last_two_weeks, 17) +} + +if o.has_rt_last_time_played { +res << vproto.pack_uint32_field(o.rt_last_time_played, 18) +} + +// [packed=false] +for _, x in o.store_tag { +res << vproto.pack_uint32_field(x, 19) +} + +// [packed=false] +for _, x in o.association { +res << zzz_vproto_internal_pack_cappoverviewappassociation(x, 20) +} + +// [packed=false] +for _, x in o.store_category { +res << vproto.pack_uint32_field(x, 23) +} + +if o.has_rt_original_release_date { +res << vproto.pack_uint32_field(o.rt_original_release_date, 25) +} + +if o.has_rt_steam_release_date { +res << vproto.pack_uint32_field(o.rt_steam_release_date, 26) +} + +if o.has_icon_hash { +res << vproto.pack_string_field(o.icon_hash, 27) +} + +if o.has_logo_hash { +res << vproto.pack_string_field(o.logo_hash, 30) +} + +if o.has_controller_support { +res << zzz_vproto_internal_pack_eappcontrollersupportlevel(o.controller_support, 31) +} + +if o.has_vr_supported { +res << vproto.pack_bool_field(o.vr_supported, 32) +} + +if o.has_metacritic_score { +res << vproto.pack_uint32_field(o.metacritic_score, 36) +} + +if o.has_size_on_disk { +res << vproto.pack_uint64_field(o.size_on_disk, 37) +} + +if o.has_third_party_mod { +res << vproto.pack_bool_field(o.third_party_mod, 38) +} + +if o.has_icon_data { +res << vproto.pack_string_field(o.icon_data, 39) +} + +if o.has_icon_data_format { +res << vproto.pack_string_field(o.icon_data_format, 40) +} + +if o.has_gameid { +res << vproto.pack_string_field(o.gameid, 41) +} + +if o.has_library_capsule_filename { +res << vproto.pack_string_field(o.library_capsule_filename, 42) +} + +// [packed=false] +for _, x in o.per_client_data { +res << zzz_vproto_internal_pack_cappoverviewperclientdata(x, 43) +} + +if o.has_most_available_clientid { +res << vproto.pack_uint64_field(o.most_available_clientid, 44) +} + +if o.has_selected_clientid { +res << vproto.pack_uint64_field(o.selected_clientid, 45) +} + +if o.has_rt_store_asset_mtime { +res << vproto.pack_uint32_field(o.rt_store_asset_mtime, 46) +} + +if o.has_rt_custom_image_mtime { +res << vproto.pack_uint32_field(o.rt_custom_image_mtime, 47) +} + +if o.has_optional_parent_app_id { +res << vproto.pack_uint32_field(o.optional_parent_app_id, 48) +} + +if o.has_owner_account_id { +res << vproto.pack_uint32_field(o.owner_account_id, 49) +} + +if o.has_compat_mapping_enabled { +res << vproto.pack_bool_field(o.compat_mapping_enabled, 50) +} + +if o.has_compat_mapping_priority { +res << vproto.pack_uint32_field(o.compat_mapping_priority, 51) +} + +if o.has_compat_mapping_tool_name { +res << vproto.pack_string_field(o.compat_mapping_tool_name, 52) +} + +if o.has_review_score_with_bombs { +res << vproto.pack_uint32_field(o.review_score_with_bombs, 53) +} + +if o.has_review_percentage_with_bombs { +res << vproto.pack_uint32_field(o.review_percentage_with_bombs, 54) +} + +if o.has_review_score_without_bombs { +res << vproto.pack_uint32_field(o.review_score_without_bombs, 55) +} + +if o.has_review_percentage_without_bombs { +res << vproto.pack_uint32_field(o.review_percentage_without_bombs, 56) +} + +if o.has_library_id { +res << vproto.pack_string_field(o.library_id, 57) +} + +return res +} + +pub fn cappoverview_unpack(buf []byte) ?CAppOverview { +mut res := CAppOverview{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_display_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.display_name = v +i = ii +} + +4 { +res.has_visible_in_game_list = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.visible_in_game_list = v +i = ii +} + +6 { +res.has_sort_as = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.sort_as = v +i = ii +} + +7 { +res.has_app_type = true +ii, v := zzz_vproto_internal_unpack_eprotoapptype(cur_buf, tag_wiretype.wire_type)? +res.app_type = v +i = ii +} + +13 { +res.has_mru_index = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.mru_index = v +i = ii +} + +14 { +res.has_rt_recent_activity_time = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rt_recent_activity_time = v +i = ii +} + +16 { +res.has_minutes_playtime_forever = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.minutes_playtime_forever = v +i = ii +} + +17 { +res.has_minutes_playtime_last_two_weeks = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.minutes_playtime_last_two_weeks = v +i = ii +} + +18 { +res.has_rt_last_time_played = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rt_last_time_played = v +i = ii +} + +19 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.store_tag << v +i = ii +} + +20 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cappoverviewappassociation(cur_buf, tag_wiretype.wire_type)? +res.association << v +i = ii +} + +23 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.store_category << v +i = ii +} + +25 { +res.has_rt_original_release_date = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rt_original_release_date = v +i = ii +} + +26 { +res.has_rt_steam_release_date = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rt_steam_release_date = v +i = ii +} + +27 { +res.has_icon_hash = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.icon_hash = v +i = ii +} + +30 { +res.has_logo_hash = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.logo_hash = v +i = ii +} + +31 { +res.has_controller_support = true +ii, v := zzz_vproto_internal_unpack_eappcontrollersupportlevel(cur_buf, tag_wiretype.wire_type)? +res.controller_support = v +i = ii +} + +32 { +res.has_vr_supported = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.vr_supported = v +i = ii +} + +36 { +res.has_metacritic_score = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.metacritic_score = v +i = ii +} + +37 { +res.has_size_on_disk = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.size_on_disk = v +i = ii +} + +38 { +res.has_third_party_mod = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.third_party_mod = v +i = ii +} + +39 { +res.has_icon_data = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.icon_data = v +i = ii +} + +40 { +res.has_icon_data_format = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.icon_data_format = v +i = ii +} + +41 { +res.has_gameid = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.gameid = v +i = ii +} + +42 { +res.has_library_capsule_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.library_capsule_filename = v +i = ii +} + +43 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cappoverviewperclientdata(cur_buf, tag_wiretype.wire_type)? +res.per_client_data << v +i = ii +} + +44 { +res.has_most_available_clientid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.most_available_clientid = v +i = ii +} + +45 { +res.has_selected_clientid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.selected_clientid = v +i = ii +} + +46 { +res.has_rt_store_asset_mtime = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rt_store_asset_mtime = v +i = ii +} + +47 { +res.has_rt_custom_image_mtime = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rt_custom_image_mtime = v +i = ii +} + +48 { +res.has_optional_parent_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.optional_parent_app_id = v +i = ii +} + +49 { +res.has_owner_account_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.owner_account_id = v +i = ii +} + +50 { +res.has_compat_mapping_enabled = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.compat_mapping_enabled = v +i = ii +} + +51 { +res.has_compat_mapping_priority = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.compat_mapping_priority = v +i = ii +} + +52 { +res.has_compat_mapping_tool_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.compat_mapping_tool_name = v +i = ii +} + +53 { +res.has_review_score_with_bombs = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.review_score_with_bombs = v +i = ii +} + +54 { +res.has_review_percentage_with_bombs = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.review_percentage_with_bombs = v +i = ii +} + +55 { +res.has_review_score_without_bombs = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.review_score_without_bombs = v +i = ii +} + +56 { +res.has_review_percentage_without_bombs = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.review_percentage_without_bombs = v +i = ii +} + +57 { +res.has_library_id = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.library_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cappoverview() CAppOverview { +return CAppOverview{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cappoverview(o CAppOverview, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cappoverview(buf []byte, tag_wiretype vproto.WireType) ?(int, CAppOverview) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cappoverview_unpack(v)? +return i, unpacked +} +pub struct CAppOverviewChange { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_overview []CAppOverview +removed_appid []u32 +} +pub fn (o &CAppOverviewChange) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.app_overview { +res << zzz_vproto_internal_pack_cappoverview(x, 1) +} + +// [packed=false] +for _, x in o.removed_appid { +res << vproto.pack_uint32_field(x, 2) +} + +return res +} + +pub fn cappoverviewchange_unpack(buf []byte) ?CAppOverviewChange { +mut res := CAppOverviewChange{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cappoverview(cur_buf, tag_wiretype.wire_type)? +res.app_overview << v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.removed_appid << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cappoverviewchange() CAppOverviewChange { +return CAppOverviewChange{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cappoverviewchange(o CAppOverviewChange, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cappoverviewchange(buf []byte, tag_wiretype vproto.WireType) ?(int, CAppOverviewChange) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cappoverviewchange_unpack(v)? +return i, unpacked +} +pub struct CAppBootstrapData { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +hidden bool +has_hidden bool +user_tag []string +} +pub fn (o &CAppBootstrapData) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_hidden { +res << vproto.pack_bool_field(o.hidden, 2) +} + +// [packed=false] +for _, x in o.user_tag { +res << vproto.pack_string_field(x, 3) +} + +return res +} + +pub fn cappbootstrapdata_unpack(buf []byte) ?CAppBootstrapData { +mut res := CAppBootstrapData{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_hidden = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.hidden = v +i = ii +} + +3 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.user_tag << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cappbootstrapdata() CAppBootstrapData { +return CAppBootstrapData{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cappbootstrapdata(o CAppBootstrapData, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cappbootstrapdata(buf []byte, tag_wiretype vproto.WireType) ?(int, CAppBootstrapData) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cappbootstrapdata_unpack(v)? +return i, unpacked +} +pub struct CLibraryBootstrapData { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_data []CAppBootstrapData +} +pub fn (o &CLibraryBootstrapData) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.app_data { +res << zzz_vproto_internal_pack_cappbootstrapdata(x, 1) +} + +return res +} + +pub fn clibrarybootstrapdata_unpack(buf []byte) ?CLibraryBootstrapData { +mut res := CLibraryBootstrapData{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cappbootstrapdata(cur_buf, tag_wiretype.wire_type)? +res.app_data << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_clibrarybootstrapdata() CLibraryBootstrapData { +return CLibraryBootstrapData{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_clibrarybootstrapdata(o CLibraryBootstrapData, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_clibrarybootstrapdata(buf []byte, tag_wiretype vproto.WireType) ?(int, CLibraryBootstrapData) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := clibrarybootstrapdata_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_auth.steamclient_pb.v b/proto/steammessages_auth.steamclient_pb.v new file mode 100644 index 0000000..7c1868c --- /dev/null +++ b/proto/steammessages_auth.steamclient_pb.v @@ -0,0 +1,349 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CCloudGamingCreateNonceRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +platform string +has_platform bool +appid u32 +has_appid bool +} +pub fn (o &CCloudGamingCreateNonceRequest) pack() []byte { +mut res := []byte{} +if o.has_platform { +res << vproto.pack_string_field(o.platform, 1) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 2) +} + +return res +} + +pub fn ccloudgamingcreatenoncerequest_unpack(buf []byte) ?CCloudGamingCreateNonceRequest { +mut res := CCloudGamingCreateNonceRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_platform = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.platform = v +i = ii +} + +2 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudgamingcreatenoncerequest() CCloudGamingCreateNonceRequest { +return CCloudGamingCreateNonceRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudgamingcreatenoncerequest(o CCloudGamingCreateNonceRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudgamingcreatenoncerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudGamingCreateNonceRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudgamingcreatenoncerequest_unpack(v)? +return i, unpacked +} +pub struct CCloudGamingCreateNonceResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +nonce string +has_nonce bool +expiry u32 +has_expiry bool +} +pub fn (o &CCloudGamingCreateNonceResponse) pack() []byte { +mut res := []byte{} +if o.has_nonce { +res << vproto.pack_string_field(o.nonce, 1) +} + +if o.has_expiry { +res << vproto.pack_uint32_field(o.expiry, 2) +} + +return res +} + +pub fn ccloudgamingcreatenonceresponse_unpack(buf []byte) ?CCloudGamingCreateNonceResponse { +mut res := CCloudGamingCreateNonceResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_nonce = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.nonce = v +i = ii +} + +2 { +res.has_expiry = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.expiry = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudgamingcreatenonceresponse() CCloudGamingCreateNonceResponse { +return CCloudGamingCreateNonceResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudgamingcreatenonceresponse(o CCloudGamingCreateNonceResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudgamingcreatenonceresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudGamingCreateNonceResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudgamingcreatenonceresponse_unpack(v)? +return i, unpacked +} +pub struct CCloudGamingGetTimeRemainingRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +platform string +has_platform bool +appid_list []u32 +} +pub fn (o &CCloudGamingGetTimeRemainingRequest) pack() []byte { +mut res := []byte{} +if o.has_platform { +res << vproto.pack_string_field(o.platform, 1) +} + +// [packed=false] +for _, x in o.appid_list { +res << vproto.pack_uint32_field(x, 2) +} + +return res +} + +pub fn ccloudgaminggettimeremainingrequest_unpack(buf []byte) ?CCloudGamingGetTimeRemainingRequest { +mut res := CCloudGamingGetTimeRemainingRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_platform = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.platform = v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid_list << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudgaminggettimeremainingrequest() CCloudGamingGetTimeRemainingRequest { +return CCloudGamingGetTimeRemainingRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudgaminggettimeremainingrequest(o CCloudGamingGetTimeRemainingRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudgaminggettimeremainingrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudGamingGetTimeRemainingRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudgaminggettimeremainingrequest_unpack(v)? +return i, unpacked +} +pub struct CCloudGamingTimeRemaining { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +minutes_remaining u32 +has_minutes_remaining bool +} +pub fn (o &CCloudGamingTimeRemaining) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_minutes_remaining { +res << vproto.pack_uint32_field(o.minutes_remaining, 2) +} + +return res +} + +pub fn ccloudgamingtimeremaining_unpack(buf []byte) ?CCloudGamingTimeRemaining { +mut res := CCloudGamingTimeRemaining{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_minutes_remaining = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.minutes_remaining = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudgamingtimeremaining() CCloudGamingTimeRemaining { +return CCloudGamingTimeRemaining{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudgamingtimeremaining(o CCloudGamingTimeRemaining, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudgamingtimeremaining(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudGamingTimeRemaining) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudgamingtimeremaining_unpack(v)? +return i, unpacked +} +pub struct CCloudGamingGetTimeRemainingResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +entries []CCloudGamingTimeRemaining +} +pub fn (o &CCloudGamingGetTimeRemainingResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.entries { +res << zzz_vproto_internal_pack_ccloudgamingtimeremaining(x, 2) +} + +return res +} + +pub fn ccloudgaminggettimeremainingresponse_unpack(buf []byte) ?CCloudGamingGetTimeRemainingResponse { +mut res := CCloudGamingGetTimeRemainingResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_ccloudgamingtimeremaining(cur_buf, tag_wiretype.wire_type)? +res.entries << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudgaminggettimeremainingresponse() CCloudGamingGetTimeRemainingResponse { +return CCloudGamingGetTimeRemainingResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudgaminggettimeremainingresponse(o CCloudGamingGetTimeRemainingResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudgaminggettimeremainingresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudGamingGetTimeRemainingResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudgaminggettimeremainingresponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_base_pb.v b/proto/steammessages_base_pb.v new file mode 100644 index 0000000..13ec70c --- /dev/null +++ b/proto/steammessages_base_pb.v @@ -0,0 +1,2614 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + +import proto.google.protobuf + +[_allow_multiple_values] +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 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_eprotoclaneventtype(e EProtoClanEventType, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_eprotoclaneventtype(buf []byte, tag_wiretype vproto.WireType) ?(int, EProtoClanEventType) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EProtoClanEventType(v) +} +[_allow_multiple_values] +enum PartnerEventNotificationType { +k_eeventstart = 0 +k_eeventbroadcaststart = 1 +k_eeventmatchstart = 2 +k_eeventpartnermaxtype = 3 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_partnereventnotificationtype(e PartnerEventNotificationType, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_partnereventnotificationtype(buf []byte, tag_wiretype vproto.WireType) ?(int, PartnerEventNotificationType) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, PartnerEventNotificationType(v) +} +pub struct CMsgIPaddress { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CMsgIPaddress) pack() []byte { +res := []byte{} +return res +} + +pub fn cmsgipaddress_unpack(buf []byte) ?CMsgIPaddress { +res := CMsgIPaddress{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgipaddress() CMsgIPaddress { +return CMsgIPaddress{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgipaddress(o CMsgIPaddress, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgipaddress(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgIPaddress) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgipaddress_unpack(v)? +return i, unpacked +} +pub struct CMsgIPaddressBucket { +mut: +unknown_fields []vproto.UnknownField +pub mut: +original_ip_address CMsgIPaddress +has_original_ip_address bool +bucket u64 +has_bucket bool +} +pub fn (o &CMsgIPaddressBucket) pack() []byte { +mut res := []byte{} +if o.has_original_ip_address { +res << zzz_vproto_internal_pack_cmsgipaddress(o.original_ip_address, 1) +} + +if o.has_bucket { +res << vproto.pack_64bit_field(o.bucket, 2) +} + +return res +} + +pub fn cmsgipaddressbucket_unpack(buf []byte) ?CMsgIPaddressBucket { +mut res := CMsgIPaddressBucket{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_original_ip_address = true +ii, v := zzz_vproto_internal_unpack_cmsgipaddress(cur_buf, tag_wiretype.wire_type)? +res.original_ip_address = v +i = ii +} + +2 { +res.has_bucket = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.bucket = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgipaddressbucket() CMsgIPaddressBucket { +return CMsgIPaddressBucket{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgipaddressbucket(o CMsgIPaddressBucket, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgipaddressbucket(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgIPaddressBucket) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgipaddressbucket_unpack(v)? +return i, unpacked +} +pub struct CMsgProtoBufHeader { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +client_sessionid int +has_client_sessionid bool +routing_appid u32 +has_routing_appid bool +jobid_source u64 +has_jobid_source bool +jobid_target u64 +has_jobid_target bool +target_job_name string +has_target_job_name bool +seq_num int +has_seq_num bool +eresult int +has_eresult bool +error_message string +has_error_message bool +auth_account_flags u32 +has_auth_account_flags bool +token_source u32 +has_token_source bool +admin_spoofing_user bool +has_admin_spoofing_user bool +transport_error int +has_transport_error bool +messageid u64 +has_messageid bool +publisher_group_id u32 +has_publisher_group_id bool +sysid u32 +has_sysid bool +trace_tag u64 +has_trace_tag bool +webapi_key_id u32 +has_webapi_key_id bool +is_from_external_source bool +has_is_from_external_source bool +forward_to_sysid []u32 +cm_sysid u32 +has_cm_sysid bool +wg_token string +has_wg_token bool +launcher_type u32 +has_launcher_type bool +realm u32 +has_realm bool +} +pub fn (o &CMsgProtoBufHeader) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_client_sessionid { +res << vproto.pack_int32_field(o.client_sessionid, 2) +} + +if o.has_routing_appid { +res << vproto.pack_uint32_field(o.routing_appid, 3) +} + +if o.has_jobid_source { +res << vproto.pack_64bit_field(o.jobid_source, 10) +} + +if o.has_jobid_target { +res << vproto.pack_64bit_field(o.jobid_target, 11) +} + +if o.has_target_job_name { +res << vproto.pack_string_field(o.target_job_name, 12) +} + +if o.has_seq_num { +res << vproto.pack_int32_field(o.seq_num, 24) +} + +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 13) +} + +if o.has_error_message { +res << vproto.pack_string_field(o.error_message, 14) +} + +if o.has_auth_account_flags { +res << vproto.pack_uint32_field(o.auth_account_flags, 16) +} + +if o.has_token_source { +res << vproto.pack_uint32_field(o.token_source, 22) +} + +if o.has_admin_spoofing_user { +res << vproto.pack_bool_field(o.admin_spoofing_user, 23) +} + +if o.has_transport_error { +res << vproto.pack_int32_field(o.transport_error, 17) +} + +if o.has_messageid { +res << vproto.pack_uint64_field(o.messageid, 18) +} + +if o.has_publisher_group_id { +res << vproto.pack_uint32_field(o.publisher_group_id, 19) +} + +if o.has_sysid { +res << vproto.pack_uint32_field(o.sysid, 20) +} + +if o.has_trace_tag { +res << vproto.pack_uint64_field(o.trace_tag, 21) +} + +if o.has_webapi_key_id { +res << vproto.pack_uint32_field(o.webapi_key_id, 25) +} + +if o.has_is_from_external_source { +res << vproto.pack_bool_field(o.is_from_external_source, 26) +} + +// [packed=false] +for _, x in o.forward_to_sysid { +res << vproto.pack_uint32_field(x, 27) +} + +if o.has_cm_sysid { +res << vproto.pack_uint32_field(o.cm_sysid, 28) +} + +if o.has_wg_token { +res << vproto.pack_string_field(o.wg_token, 30) +} + +if o.has_launcher_type { +res << vproto.pack_uint32_field(o.launcher_type, 31) +} + +if o.has_realm { +res << vproto.pack_uint32_field(o.realm, 32) +} + +return res +} + +pub fn cmsgprotobufheader_unpack(buf []byte) ?CMsgProtoBufHeader { +mut res := CMsgProtoBufHeader{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_client_sessionid = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.client_sessionid = v +i = ii +} + +3 { +res.has_routing_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.routing_appid = v +i = ii +} + +10 { +res.has_jobid_source = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.jobid_source = v +i = ii +} + +11 { +res.has_jobid_target = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.jobid_target = v +i = ii +} + +12 { +res.has_target_job_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.target_job_name = v +i = ii +} + +24 { +res.has_seq_num = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.seq_num = v +i = ii +} + +13 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +14 { +res.has_error_message = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.error_message = v +i = ii +} + +16 { +res.has_auth_account_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.auth_account_flags = v +i = ii +} + +22 { +res.has_token_source = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.token_source = v +i = ii +} + +23 { +res.has_admin_spoofing_user = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.admin_spoofing_user = v +i = ii +} + +17 { +res.has_transport_error = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.transport_error = v +i = ii +} + +18 { +res.has_messageid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.messageid = v +i = ii +} + +19 { +res.has_publisher_group_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.publisher_group_id = v +i = ii +} + +20 { +res.has_sysid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.sysid = v +i = ii +} + +21 { +res.has_trace_tag = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.trace_tag = v +i = ii +} + +25 { +res.has_webapi_key_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.webapi_key_id = v +i = ii +} + +26 { +res.has_is_from_external_source = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_from_external_source = v +i = ii +} + +27 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.forward_to_sysid << v +i = ii +} + +28 { +res.has_cm_sysid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cm_sysid = v +i = ii +} + +30 { +res.has_wg_token = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.wg_token = v +i = ii +} + +31 { +res.has_launcher_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.launcher_type = v +i = ii +} + +32 { +res.has_realm = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.realm = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgprotobufheader() CMsgProtoBufHeader { +return CMsgProtoBufHeader{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgprotobufheader(o CMsgProtoBufHeader, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgprotobufheader(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgProtoBufHeader) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgprotobufheader_unpack(v)? +return i, unpacked +} +pub struct CMsgMulti { +mut: +unknown_fields []vproto.UnknownField +pub mut: +size_unzipped u32 +has_size_unzipped bool +message_body []byte +has_message_body bool +} +pub fn (o &CMsgMulti) pack() []byte { +mut res := []byte{} +if o.has_size_unzipped { +res << vproto.pack_uint32_field(o.size_unzipped, 1) +} + +if o.has_message_body { +res << vproto.pack_bytes_field(o.message_body, 2) +} + +return res +} + +pub fn cmsgmulti_unpack(buf []byte) ?CMsgMulti { +mut res := CMsgMulti{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_size_unzipped = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.size_unzipped = v +i = ii +} + +2 { +res.has_message_body = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.message_body = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgmulti() CMsgMulti { +return CMsgMulti{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgmulti(o CMsgMulti, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgmulti(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgMulti) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgmulti_unpack(v)? +return i, unpacked +} +pub struct CMsgProtobufWrapped { +mut: +unknown_fields []vproto.UnknownField +pub mut: +message_body []byte +has_message_body bool +} +pub fn (o &CMsgProtobufWrapped) pack() []byte { +mut res := []byte{} +if o.has_message_body { +res << vproto.pack_bytes_field(o.message_body, 1) +} + +return res +} + +pub fn cmsgprotobufwrapped_unpack(buf []byte) ?CMsgProtobufWrapped { +mut res := CMsgProtobufWrapped{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_message_body = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.message_body = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgprotobufwrapped() CMsgProtobufWrapped { +return CMsgProtobufWrapped{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgprotobufwrapped(o CMsgProtobufWrapped, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgprotobufwrapped(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgProtobufWrapped) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgprotobufwrapped_unpack(v)? +return i, unpacked +} +pub struct CMsgAuthTicket { +mut: +unknown_fields []vproto.UnknownField +pub mut: +estate u32 +has_estate bool +eresult u32 +has_eresult bool +steamid u64 +has_steamid bool +gameid u64 +has_gameid bool +h_steam_pipe u32 +has_h_steam_pipe bool +ticket_crc u32 +has_ticket_crc bool +ticket []byte +has_ticket bool +} +pub fn (o &CMsgAuthTicket) pack() []byte { +mut res := []byte{} +if o.has_estate { +res << vproto.pack_uint32_field(o.estate, 1) +} + +if o.has_eresult { +res << vproto.pack_uint32_field(o.eresult, 2) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 3) +} + +if o.has_gameid { +res << vproto.pack_64bit_field(o.gameid, 4) +} + +if o.has_h_steam_pipe { +res << vproto.pack_uint32_field(o.h_steam_pipe, 5) +} + +if o.has_ticket_crc { +res << vproto.pack_uint32_field(o.ticket_crc, 6) +} + +if o.has_ticket { +res << vproto.pack_bytes_field(o.ticket, 7) +} + +return res +} + +pub fn cmsgauthticket_unpack(buf []byte) ?CMsgAuthTicket { +mut res := CMsgAuthTicket{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_estate = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.estate = v +i = ii +} + +2 { +res.has_eresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +3 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +4 { +res.has_gameid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.gameid = v +i = ii +} + +5 { +res.has_h_steam_pipe = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.h_steam_pipe = v +i = ii +} + +6 { +res.has_ticket_crc = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ticket_crc = v +i = ii +} + +7 { +res.has_ticket = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.ticket = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgauthticket() CMsgAuthTicket { +return CMsgAuthTicket{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgauthticket(o CMsgAuthTicket, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgauthticket(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgAuthTicket) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgauthticket_unpack(v)? +return i, unpacked +} +pub struct CCddbappDetailCommon { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +name string +has_name bool +icon string +has_icon bool +logo string +has_logo bool +logo_small string +has_logo_small bool +tool bool +has_tool bool +demo bool +has_demo bool +media bool +has_media bool +community_visible_stats bool +has_community_visible_stats bool +friendly_name string +has_friendly_name bool +propagation string +has_propagation bool +has_adult_content bool +has_has_adult_content bool +} +pub fn (o &CCddbappDetailCommon) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_name { +res << vproto.pack_string_field(o.name, 2) +} + +if o.has_icon { +res << vproto.pack_string_field(o.icon, 3) +} + +if o.has_logo { +res << vproto.pack_string_field(o.logo, 4) +} + +if o.has_logo_small { +res << vproto.pack_string_field(o.logo_small, 5) +} + +if o.has_tool { +res << vproto.pack_bool_field(o.tool, 6) +} + +if o.has_demo { +res << vproto.pack_bool_field(o.demo, 7) +} + +if o.has_media { +res << vproto.pack_bool_field(o.media, 8) +} + +if o.has_community_visible_stats { +res << vproto.pack_bool_field(o.community_visible_stats, 9) +} + +if o.has_friendly_name { +res << vproto.pack_string_field(o.friendly_name, 10) +} + +if o.has_propagation { +res << vproto.pack_string_field(o.propagation, 11) +} + +if o.has_has_adult_content { +res << vproto.pack_bool_field(o.has_adult_content, 12) +} + +return res +} + +pub fn ccddbappdetailcommon_unpack(buf []byte) ?CCddbappDetailCommon { +mut res := CCddbappDetailCommon{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +3 { +res.has_icon = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.icon = v +i = ii +} + +4 { +res.has_logo = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.logo = v +i = ii +} + +5 { +res.has_logo_small = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.logo_small = v +i = ii +} + +6 { +res.has_tool = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.tool = v +i = ii +} + +7 { +res.has_demo = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.demo = v +i = ii +} + +8 { +res.has_media = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.media = v +i = ii +} + +9 { +res.has_community_visible_stats = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.community_visible_stats = v +i = ii +} + +10 { +res.has_friendly_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.friendly_name = v +i = ii +} + +11 { +res.has_propagation = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.propagation = v +i = ii +} + +12 { +res.has_has_adult_content = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.has_adult_content = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccddbappdetailcommon() CCddbappDetailCommon { +return CCddbappDetailCommon{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccddbappdetailcommon(o CCddbappDetailCommon, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccddbappdetailcommon(buf []byte, tag_wiretype vproto.WireType) ?(int, CCddbappDetailCommon) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccddbappdetailcommon_unpack(v)? +return i, unpacked +} +pub struct CMsgAppRights { +mut: +unknown_fields []vproto.UnknownField +pub mut: +edit_info bool +has_edit_info bool +publish bool +has_publish bool +view_error_data bool +has_view_error_data bool +download bool +has_download bool +upload_cdkeys bool +has_upload_cdkeys bool +generate_cdkeys bool +has_generate_cdkeys bool +view_financials bool +has_view_financials bool +manage_ceg bool +has_manage_ceg bool +manage_signing bool +has_manage_signing bool +manage_cdkeys bool +has_manage_cdkeys bool +edit_marketing bool +has_edit_marketing bool +economy_support bool +has_economy_support bool +economy_support_supervisor bool +has_economy_support_supervisor bool +manage_pricing bool +has_manage_pricing bool +broadcast_live bool +has_broadcast_live bool +view_marketing_traffic bool +has_view_marketing_traffic bool +} +pub fn (o &CMsgAppRights) pack() []byte { +mut res := []byte{} +if o.has_edit_info { +res << vproto.pack_bool_field(o.edit_info, 1) +} + +if o.has_publish { +res << vproto.pack_bool_field(o.publish, 2) +} + +if o.has_view_error_data { +res << vproto.pack_bool_field(o.view_error_data, 3) +} + +if o.has_download { +res << vproto.pack_bool_field(o.download, 4) +} + +if o.has_upload_cdkeys { +res << vproto.pack_bool_field(o.upload_cdkeys, 5) +} + +if o.has_generate_cdkeys { +res << vproto.pack_bool_field(o.generate_cdkeys, 6) +} + +if o.has_view_financials { +res << vproto.pack_bool_field(o.view_financials, 7) +} + +if o.has_manage_ceg { +res << vproto.pack_bool_field(o.manage_ceg, 8) +} + +if o.has_manage_signing { +res << vproto.pack_bool_field(o.manage_signing, 9) +} + +if o.has_manage_cdkeys { +res << vproto.pack_bool_field(o.manage_cdkeys, 10) +} + +if o.has_edit_marketing { +res << vproto.pack_bool_field(o.edit_marketing, 11) +} + +if o.has_economy_support { +res << vproto.pack_bool_field(o.economy_support, 12) +} + +if o.has_economy_support_supervisor { +res << vproto.pack_bool_field(o.economy_support_supervisor, 13) +} + +if o.has_manage_pricing { +res << vproto.pack_bool_field(o.manage_pricing, 14) +} + +if o.has_broadcast_live { +res << vproto.pack_bool_field(o.broadcast_live, 15) +} + +if o.has_view_marketing_traffic { +res << vproto.pack_bool_field(o.view_marketing_traffic, 16) +} + +return res +} + +pub fn cmsgapprights_unpack(buf []byte) ?CMsgAppRights { +mut res := CMsgAppRights{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_edit_info = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.edit_info = v +i = ii +} + +2 { +res.has_publish = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.publish = v +i = ii +} + +3 { +res.has_view_error_data = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.view_error_data = v +i = ii +} + +4 { +res.has_download = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.download = v +i = ii +} + +5 { +res.has_upload_cdkeys = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.upload_cdkeys = v +i = ii +} + +6 { +res.has_generate_cdkeys = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.generate_cdkeys = v +i = ii +} + +7 { +res.has_view_financials = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.view_financials = v +i = ii +} + +8 { +res.has_manage_ceg = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.manage_ceg = v +i = ii +} + +9 { +res.has_manage_signing = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.manage_signing = v +i = ii +} + +10 { +res.has_manage_cdkeys = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.manage_cdkeys = v +i = ii +} + +11 { +res.has_edit_marketing = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.edit_marketing = v +i = ii +} + +12 { +res.has_economy_support = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.economy_support = v +i = ii +} + +13 { +res.has_economy_support_supervisor = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.economy_support_supervisor = v +i = ii +} + +14 { +res.has_manage_pricing = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.manage_pricing = v +i = ii +} + +15 { +res.has_broadcast_live = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_live = v +i = ii +} + +16 { +res.has_view_marketing_traffic = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.view_marketing_traffic = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgapprights() CMsgAppRights { +return CMsgAppRights{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgapprights(o CMsgAppRights, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgapprights(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgAppRights) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgapprights_unpack(v)? +return i, unpacked +} +pub struct CCuratorPreferences { +mut: +unknown_fields []vproto.UnknownField +pub mut: +supported_languages u32 +has_supported_languages bool +platform_windows bool +has_platform_windows bool +platform_mac bool +has_platform_mac bool +platform_linux bool +has_platform_linux bool +vr_content bool +has_vr_content bool +adult_content_violence bool +has_adult_content_violence bool +adult_content_sex bool +has_adult_content_sex bool +timestamp_updated u32 +has_timestamp_updated bool +tagids_curated []u32 +tagids_filtered []u32 +website_title string +has_website_title bool +website_url string +has_website_url bool +discussion_url string +has_discussion_url bool +show_broadcast bool +has_show_broadcast bool +} +pub fn (o &CCuratorPreferences) pack() []byte { +mut res := []byte{} +if o.has_supported_languages { +res << vproto.pack_uint32_field(o.supported_languages, 1) +} + +if o.has_platform_windows { +res << vproto.pack_bool_field(o.platform_windows, 2) +} + +if o.has_platform_mac { +res << vproto.pack_bool_field(o.platform_mac, 3) +} + +if o.has_platform_linux { +res << vproto.pack_bool_field(o.platform_linux, 4) +} + +if o.has_vr_content { +res << vproto.pack_bool_field(o.vr_content, 5) +} + +if o.has_adult_content_violence { +res << vproto.pack_bool_field(o.adult_content_violence, 6) +} + +if o.has_adult_content_sex { +res << vproto.pack_bool_field(o.adult_content_sex, 7) +} + +if o.has_timestamp_updated { +res << vproto.pack_uint32_field(o.timestamp_updated, 8) +} + +// [packed=false] +for _, x in o.tagids_curated { +res << vproto.pack_uint32_field(x, 9) +} + +// [packed=false] +for _, x in o.tagids_filtered { +res << vproto.pack_uint32_field(x, 10) +} + +if o.has_website_title { +res << vproto.pack_string_field(o.website_title, 11) +} + +if o.has_website_url { +res << vproto.pack_string_field(o.website_url, 12) +} + +if o.has_discussion_url { +res << vproto.pack_string_field(o.discussion_url, 13) +} + +if o.has_show_broadcast { +res << vproto.pack_bool_field(o.show_broadcast, 14) +} + +return res +} + +pub fn ccuratorpreferences_unpack(buf []byte) ?CCuratorPreferences { +mut res := CCuratorPreferences{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_supported_languages = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.supported_languages = v +i = ii +} + +2 { +res.has_platform_windows = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.platform_windows = v +i = ii +} + +3 { +res.has_platform_mac = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.platform_mac = v +i = ii +} + +4 { +res.has_platform_linux = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.platform_linux = v +i = ii +} + +5 { +res.has_vr_content = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.vr_content = v +i = ii +} + +6 { +res.has_adult_content_violence = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.adult_content_violence = v +i = ii +} + +7 { +res.has_adult_content_sex = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.adult_content_sex = v +i = ii +} + +8 { +res.has_timestamp_updated = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp_updated = v +i = ii +} + +9 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.tagids_curated << v +i = ii +} + +10 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.tagids_filtered << v +i = ii +} + +11 { +res.has_website_title = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.website_title = v +i = ii +} + +12 { +res.has_website_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.website_url = v +i = ii +} + +13 { +res.has_discussion_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.discussion_url = v +i = ii +} + +14 { +res.has_show_broadcast = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.show_broadcast = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccuratorpreferences() CCuratorPreferences { +return CCuratorPreferences{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccuratorpreferences(o CCuratorPreferences, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccuratorpreferences(buf []byte, tag_wiretype vproto.WireType) ?(int, CCuratorPreferences) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccuratorpreferences_unpack(v)? +return i, unpacked +} +pub struct CLocalizationToken { +mut: +unknown_fields []vproto.UnknownField +pub mut: +language u32 +has_language bool +localized_string string +has_localized_string bool +} +pub fn (o &CLocalizationToken) pack() []byte { +mut res := []byte{} +if o.has_language { +res << vproto.pack_uint32_field(o.language, 1) +} + +if o.has_localized_string { +res << vproto.pack_string_field(o.localized_string, 2) +} + +return res +} + +pub fn clocalizationtoken_unpack(buf []byte) ?CLocalizationToken { +mut res := CLocalizationToken{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_language = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +2 { +res.has_localized_string = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.localized_string = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_clocalizationtoken() CLocalizationToken { +return CLocalizationToken{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_clocalizationtoken(o CLocalizationToken, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_clocalizationtoken(buf []byte, tag_wiretype vproto.WireType) ?(int, CLocalizationToken) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := clocalizationtoken_unpack(v)? +return i, unpacked +} +pub struct CClanEventUserNewsTuple { +mut: +unknown_fields []vproto.UnknownField +pub mut: +clanid u32 +has_clanid bool +event_gid u64 +has_event_gid bool +announcement_gid u64 +has_announcement_gid bool +rtime_start u32 +has_rtime_start bool +rtime_end u32 +has_rtime_end bool +priority_score u32 +has_priority_score bool +@type u32 +has_type bool +clamp_range_slot u32 +has_clamp_range_slot bool +appid u32 +has_appid bool +rtime32_last_modified u32 +has_rtime32_last_modified bool +} +pub fn (o &CClanEventUserNewsTuple) pack() []byte { +mut res := []byte{} +if o.has_clanid { +res << vproto.pack_uint32_field(o.clanid, 1) +} + +if o.has_event_gid { +res << vproto.pack_64bit_field(o.event_gid, 2) +} + +if o.has_announcement_gid { +res << vproto.pack_64bit_field(o.announcement_gid, 3) +} + +if o.has_rtime_start { +res << vproto.pack_uint32_field(o.rtime_start, 4) +} + +if o.has_rtime_end { +res << vproto.pack_uint32_field(o.rtime_end, 5) +} + +if o.has_priority_score { +res << vproto.pack_uint32_field(o.priority_score, 6) +} + +if o.has_type { +res << vproto.pack_uint32_field(o.@type, 7) +} + +if o.has_clamp_range_slot { +res << vproto.pack_uint32_field(o.clamp_range_slot, 8) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 9) +} + +if o.has_rtime32_last_modified { +res << vproto.pack_uint32_field(o.rtime32_last_modified, 10) +} + +return res +} + +pub fn cclaneventusernewstuple_unpack(buf []byte) ?CClanEventUserNewsTuple { +mut res := CClanEventUserNewsTuple{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_clanid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.clanid = v +i = ii +} + +2 { +res.has_event_gid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.event_gid = v +i = ii +} + +3 { +res.has_announcement_gid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.announcement_gid = v +i = ii +} + +4 { +res.has_rtime_start = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rtime_start = v +i = ii +} + +5 { +res.has_rtime_end = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rtime_end = v +i = ii +} + +6 { +res.has_priority_score = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.priority_score = v +i = ii +} + +7 { +res.has_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.@type = v +i = ii +} + +8 { +res.has_clamp_range_slot = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.clamp_range_slot = v +i = ii +} + +9 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +10 { +res.has_rtime32_last_modified = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rtime32_last_modified = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cclaneventusernewstuple() CClanEventUserNewsTuple { +return CClanEventUserNewsTuple{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cclaneventusernewstuple(o CClanEventUserNewsTuple, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cclaneventusernewstuple(buf []byte, tag_wiretype vproto.WireType) ?(int, CClanEventUserNewsTuple) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cclaneventusernewstuple_unpack(v)? +return i, unpacked +} +pub struct CClanMatchEventByRange { +mut: +unknown_fields []vproto.UnknownField +pub mut: +rtime_before u32 +has_rtime_before bool +rtime_after u32 +has_rtime_after bool +qualified u32 +has_qualified bool +events []CClanEventUserNewsTuple +} +pub fn (o &CClanMatchEventByRange) pack() []byte { +mut res := []byte{} +if o.has_rtime_before { +res << vproto.pack_uint32_field(o.rtime_before, 1) +} + +if o.has_rtime_after { +res << vproto.pack_uint32_field(o.rtime_after, 2) +} + +if o.has_qualified { +res << vproto.pack_uint32_field(o.qualified, 3) +} + +// [packed=false] +for _, x in o.events { +res << zzz_vproto_internal_pack_cclaneventusernewstuple(x, 4) +} + +return res +} + +pub fn cclanmatcheventbyrange_unpack(buf []byte) ?CClanMatchEventByRange { +mut res := CClanMatchEventByRange{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_rtime_before = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rtime_before = v +i = ii +} + +2 { +res.has_rtime_after = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rtime_after = v +i = ii +} + +3 { +res.has_qualified = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.qualified = v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cclaneventusernewstuple(cur_buf, tag_wiretype.wire_type)? +res.events << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cclanmatcheventbyrange() CClanMatchEventByRange { +return CClanMatchEventByRange{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cclanmatcheventbyrange(o CClanMatchEventByRange, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cclanmatcheventbyrange(buf []byte, tag_wiretype vproto.WireType) ?(int, CClanMatchEventByRange) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cclanmatcheventbyrange_unpack(v)? +return i, unpacked +} +pub struct CCommunityClanAnnouncementInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +gid u64 +has_gid bool +clanid u64 +has_clanid bool +posterid u64 +has_posterid bool +headline string +has_headline bool +posttime u32 +has_posttime bool +updatetime u32 +has_updatetime bool +body string +has_body bool +commentcount int +has_commentcount bool +tags []string +language int +has_language bool +hidden bool +has_hidden bool +forum_topic_id u64 +has_forum_topic_id bool +event_gid u64 +has_event_gid bool +voteupcount int +has_voteupcount bool +votedowncount int +has_votedowncount bool +} +pub fn (o &CCommunityClanAnnouncementInfo) pack() []byte { +mut res := []byte{} +if o.has_gid { +res << vproto.pack_uint64_field(o.gid, 1) +} + +if o.has_clanid { +res << vproto.pack_uint64_field(o.clanid, 2) +} + +if o.has_posterid { +res << vproto.pack_uint64_field(o.posterid, 3) +} + +if o.has_headline { +res << vproto.pack_string_field(o.headline, 4) +} + +if o.has_posttime { +res << vproto.pack_uint32_field(o.posttime, 5) +} + +if o.has_updatetime { +res << vproto.pack_uint32_field(o.updatetime, 6) +} + +if o.has_body { +res << vproto.pack_string_field(o.body, 7) +} + +if o.has_commentcount { +res << vproto.pack_int32_field(o.commentcount, 8) +} + +// [packed=false] +for _, x in o.tags { +res << vproto.pack_string_field(x, 9) +} + +if o.has_language { +res << vproto.pack_int32_field(o.language, 10) +} + +if o.has_hidden { +res << vproto.pack_bool_field(o.hidden, 11) +} + +if o.has_forum_topic_id { +res << vproto.pack_64bit_field(o.forum_topic_id, 12) +} + +if o.has_event_gid { +res << vproto.pack_64bit_field(o.event_gid, 13) +} + +if o.has_voteupcount { +res << vproto.pack_int32_field(o.voteupcount, 14) +} + +if o.has_votedowncount { +res << vproto.pack_int32_field(o.votedowncount, 15) +} + +return res +} + +pub fn ccommunityclanannouncementinfo_unpack(buf []byte) ?CCommunityClanAnnouncementInfo { +mut res := CCommunityClanAnnouncementInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_gid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.gid = v +i = ii +} + +2 { +res.has_clanid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.clanid = v +i = ii +} + +3 { +res.has_posterid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.posterid = v +i = ii +} + +4 { +res.has_headline = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.headline = v +i = ii +} + +5 { +res.has_posttime = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.posttime = v +i = ii +} + +6 { +res.has_updatetime = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.updatetime = v +i = ii +} + +7 { +res.has_body = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.body = v +i = ii +} + +8 { +res.has_commentcount = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.commentcount = v +i = ii +} + +9 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.tags << v +i = ii +} + +10 { +res.has_language = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +11 { +res.has_hidden = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.hidden = v +i = ii +} + +12 { +res.has_forum_topic_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.forum_topic_id = v +i = ii +} + +13 { +res.has_event_gid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.event_gid = v +i = ii +} + +14 { +res.has_voteupcount = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.voteupcount = v +i = ii +} + +15 { +res.has_votedowncount = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.votedowncount = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccommunityclanannouncementinfo() CCommunityClanAnnouncementInfo { +return CCommunityClanAnnouncementInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccommunityclanannouncementinfo(o CCommunityClanAnnouncementInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccommunityclanannouncementinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CCommunityClanAnnouncementInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccommunityclanannouncementinfo_unpack(v)? +return i, unpacked +} +pub struct CClanEventData { +mut: +unknown_fields []vproto.UnknownField +pub mut: +gid u64 +has_gid bool +clan_steamid u64 +has_clan_steamid bool +event_name string +has_event_name bool +event_type EProtoClanEventType +has_event_type bool +appid u32 +has_appid bool +server_address string +has_server_address bool +server_password string +has_server_password bool +rtime32_start_time u32 +has_rtime32_start_time bool +rtime32_end_time u32 +has_rtime32_end_time bool +comment_count int +has_comment_count bool +creator_steamid u64 +has_creator_steamid bool +last_update_steamid u64 +has_last_update_steamid bool +event_notes string +has_event_notes bool +jsondata string +has_jsondata bool +announcement_body CCommunityClanAnnouncementInfo +has_announcement_body bool +published bool +has_published bool +hidden bool +has_hidden bool +rtime32_visibility_start u32 +has_rtime32_visibility_start bool +rtime32_visibility_end u32 +has_rtime32_visibility_end bool +broadcaster_accountid u32 +has_broadcaster_accountid bool +follower_count u32 +has_follower_count bool +ignore_count u32 +has_ignore_count bool +forum_topic_id u64 +has_forum_topic_id bool +rtime32_last_modified u32 +has_rtime32_last_modified bool +news_post_gid u64 +has_news_post_gid bool +rtime_mod_reviewed u32 +has_rtime_mod_reviewed bool +} +pub fn (o &CClanEventData) pack() []byte { +mut res := []byte{} +if o.has_gid { +res << vproto.pack_64bit_field(o.gid, 1) +} + +if o.has_clan_steamid { +res << vproto.pack_64bit_field(o.clan_steamid, 2) +} + +if o.has_event_name { +res << vproto.pack_string_field(o.event_name, 3) +} + +if o.has_event_type { +res << zzz_vproto_internal_pack_eprotoclaneventtype(o.event_type, 4) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 5) +} + +if o.has_server_address { +res << vproto.pack_string_field(o.server_address, 6) +} + +if o.has_server_password { +res << vproto.pack_string_field(o.server_password, 7) +} + +if o.has_rtime32_start_time { +res << vproto.pack_uint32_field(o.rtime32_start_time, 8) +} + +if o.has_rtime32_end_time { +res << vproto.pack_uint32_field(o.rtime32_end_time, 9) +} + +if o.has_comment_count { +res << vproto.pack_int32_field(o.comment_count, 10) +} + +if o.has_creator_steamid { +res << vproto.pack_64bit_field(o.creator_steamid, 11) +} + +if o.has_last_update_steamid { +res << vproto.pack_64bit_field(o.last_update_steamid, 12) +} + +if o.has_event_notes { +res << vproto.pack_string_field(o.event_notes, 13) +} + +if o.has_jsondata { +res << vproto.pack_string_field(o.jsondata, 14) +} + +if o.has_announcement_body { +res << zzz_vproto_internal_pack_ccommunityclanannouncementinfo(o.announcement_body, 15) +} + +if o.has_published { +res << vproto.pack_bool_field(o.published, 16) +} + +if o.has_hidden { +res << vproto.pack_bool_field(o.hidden, 17) +} + +if o.has_rtime32_visibility_start { +res << vproto.pack_uint32_field(o.rtime32_visibility_start, 18) +} + +if o.has_rtime32_visibility_end { +res << vproto.pack_uint32_field(o.rtime32_visibility_end, 19) +} + +if o.has_broadcaster_accountid { +res << vproto.pack_uint32_field(o.broadcaster_accountid, 20) +} + +if o.has_follower_count { +res << vproto.pack_uint32_field(o.follower_count, 21) +} + +if o.has_ignore_count { +res << vproto.pack_uint32_field(o.ignore_count, 22) +} + +if o.has_forum_topic_id { +res << vproto.pack_64bit_field(o.forum_topic_id, 23) +} + +if o.has_rtime32_last_modified { +res << vproto.pack_uint32_field(o.rtime32_last_modified, 24) +} + +if o.has_news_post_gid { +res << vproto.pack_64bit_field(o.news_post_gid, 25) +} + +if o.has_rtime_mod_reviewed { +res << vproto.pack_uint32_field(o.rtime_mod_reviewed, 26) +} + +return res +} + +pub fn cclaneventdata_unpack(buf []byte) ?CClanEventData { +mut res := CClanEventData{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_gid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.gid = v +i = ii +} + +2 { +res.has_clan_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.clan_steamid = v +i = ii +} + +3 { +res.has_event_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.event_name = v +i = ii +} + +4 { +res.has_event_type = true +ii, v := zzz_vproto_internal_unpack_eprotoclaneventtype(cur_buf, tag_wiretype.wire_type)? +res.event_type = v +i = ii +} + +5 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +6 { +res.has_server_address = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.server_address = v +i = ii +} + +7 { +res.has_server_password = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.server_password = v +i = ii +} + +8 { +res.has_rtime32_start_time = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rtime32_start_time = v +i = ii +} + +9 { +res.has_rtime32_end_time = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rtime32_end_time = v +i = ii +} + +10 { +res.has_comment_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.comment_count = v +i = ii +} + +11 { +res.has_creator_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.creator_steamid = v +i = ii +} + +12 { +res.has_last_update_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.last_update_steamid = v +i = ii +} + +13 { +res.has_event_notes = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.event_notes = v +i = ii +} + +14 { +res.has_jsondata = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.jsondata = v +i = ii +} + +15 { +res.has_announcement_body = true +ii, v := zzz_vproto_internal_unpack_ccommunityclanannouncementinfo(cur_buf, tag_wiretype.wire_type)? +res.announcement_body = v +i = ii +} + +16 { +res.has_published = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.published = v +i = ii +} + +17 { +res.has_hidden = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.hidden = v +i = ii +} + +18 { +res.has_rtime32_visibility_start = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rtime32_visibility_start = v +i = ii +} + +19 { +res.has_rtime32_visibility_end = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rtime32_visibility_end = v +i = ii +} + +20 { +res.has_broadcaster_accountid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.broadcaster_accountid = v +i = ii +} + +21 { +res.has_follower_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.follower_count = v +i = ii +} + +22 { +res.has_ignore_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ignore_count = v +i = ii +} + +23 { +res.has_forum_topic_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.forum_topic_id = v +i = ii +} + +24 { +res.has_rtime32_last_modified = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rtime32_last_modified = v +i = ii +} + +25 { +res.has_news_post_gid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.news_post_gid = v +i = ii +} + +26 { +res.has_rtime_mod_reviewed = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rtime_mod_reviewed = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cclaneventdata() CClanEventData { +return CClanEventData{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cclaneventdata(o CClanEventData, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cclaneventdata(buf []byte, tag_wiretype vproto.WireType) ?(int, CClanEventData) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cclaneventdata_unpack(v)? +return i, unpacked +} +pub struct CBillingAddress { +mut: +unknown_fields []vproto.UnknownField +pub mut: +first_name string +has_first_name bool +last_name string +has_last_name bool +address1 string +has_address1 bool +address2 string +has_address2 bool +city string +has_city bool +us_state string +has_us_state bool +country_code string +has_country_code bool +postcode string +has_postcode bool +zip_plus4 int +has_zip_plus4 bool +phone string +has_phone bool +} +pub fn (o &CBillingAddress) pack() []byte { +mut res := []byte{} +if o.has_first_name { +res << vproto.pack_string_field(o.first_name, 1) +} + +if o.has_last_name { +res << vproto.pack_string_field(o.last_name, 2) +} + +if o.has_address1 { +res << vproto.pack_string_field(o.address1, 3) +} + +if o.has_address2 { +res << vproto.pack_string_field(o.address2, 4) +} + +if o.has_city { +res << vproto.pack_string_field(o.city, 5) +} + +if o.has_us_state { +res << vproto.pack_string_field(o.us_state, 6) +} + +if o.has_country_code { +res << vproto.pack_string_field(o.country_code, 7) +} + +if o.has_postcode { +res << vproto.pack_string_field(o.postcode, 8) +} + +if o.has_zip_plus4 { +res << vproto.pack_int32_field(o.zip_plus4, 9) +} + +if o.has_phone { +res << vproto.pack_string_field(o.phone, 10) +} + +return res +} + +pub fn cbillingaddress_unpack(buf []byte) ?CBillingAddress { +mut res := CBillingAddress{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_first_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.first_name = v +i = ii +} + +2 { +res.has_last_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.last_name = v +i = ii +} + +3 { +res.has_address1 = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.address1 = v +i = ii +} + +4 { +res.has_address2 = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.address2 = v +i = ii +} + +5 { +res.has_city = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.city = v +i = ii +} + +6 { +res.has_us_state = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.us_state = v +i = ii +} + +7 { +res.has_country_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.country_code = v +i = ii +} + +8 { +res.has_postcode = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.postcode = v +i = ii +} + +9 { +res.has_zip_plus4 = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.zip_plus4 = v +i = ii +} + +10 { +res.has_phone = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.phone = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbillingaddress() CBillingAddress { +return CBillingAddress{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbillingaddress(o CBillingAddress, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbillingaddress(buf []byte, tag_wiretype vproto.WireType) ?(int, CBillingAddress) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbillingaddress_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_broadcast.steamclient_pb.v b/proto/steammessages_broadcast.steamclient_pb.v new file mode 100644 index 0000000..a4567a4 --- /dev/null +++ b/proto/steammessages_broadcast.steamclient_pb.v @@ -0,0 +1,7011 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +[_allow_multiple_values] +enum EBroadcastWatchLocation { +k_ebroadcastwatchlocation_invalid = 0 +k_ebroadcastwatchlocation_steamtv_tab = 1 +k_ebroadcastwatchlocation_steamtv_watchparty = 2 +k_ebroadcastwatchlocation_chat_tab = 3 +k_ebroadcastwatchlocation_chat_watchparty = 4 +k_ebroadcastwatchlocation_communitypage = 5 +k_ebroadcastwatchlocation_storeapppage = 6 +k_ebroadcastwatchlocation_ingame = 7 +k_ebroadcastwatchlocation_bigpicture = 8 +k_ebroadcastwatchlocation_salespage = 9 +k_ebroadcastwatchlocation_curatorpage = 10 +k_ebroadcastwatchlocation_developerpage = 11 +k_ebroadcastwatchlocation_chat_friends = 12 +k_ebroadcastwatchlocation_steamtv_web = 13 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_ebroadcastwatchlocation(e EBroadcastWatchLocation, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_ebroadcastwatchlocation(buf []byte, tag_wiretype vproto.WireType) ?(int, EBroadcastWatchLocation) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EBroadcastWatchLocation(v) +} +[_allow_multiple_values] +enum EBroadcastChatPermission { +k_ebroadcastchatpermissionpublic = 0 +k_ebroadcastchatpermissionownsapp = 1 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_ebroadcastchatpermission(e EBroadcastChatPermission, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_ebroadcastchatpermission(buf []byte, tag_wiretype vproto.WireType) ?(int, EBroadcastChatPermission) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EBroadcastChatPermission(v) +} +pub struct CBroadcastBeginBroadcastSessionRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +permission int +has_permission bool +gameid u64 +has_gameid bool +client_instance_id u64 +has_client_instance_id bool +title string +has_title bool +cellid u32 +has_cellid bool +rtmp_token u64 +has_rtmp_token bool +thumbnail_upload bool +has_thumbnail_upload bool +client_beta string +has_client_beta bool +sysid u32 +has_sysid bool +allow_webrtc bool +has_allow_webrtc bool +} +pub fn (o &CBroadcastBeginBroadcastSessionRequest) pack() []byte { +mut res := []byte{} +if o.has_permission { +res << vproto.pack_int32_field(o.permission, 1) +} + +if o.has_gameid { +res << vproto.pack_uint64_field(o.gameid, 2) +} + +if o.has_client_instance_id { +res << vproto.pack_uint64_field(o.client_instance_id, 3) +} + +if o.has_title { +res << vproto.pack_string_field(o.title, 4) +} + +if o.has_cellid { +res << vproto.pack_uint32_field(o.cellid, 5) +} + +if o.has_rtmp_token { +res << vproto.pack_uint64_field(o.rtmp_token, 6) +} + +if o.has_thumbnail_upload { +res << vproto.pack_bool_field(o.thumbnail_upload, 7) +} + +if o.has_client_beta { +res << vproto.pack_string_field(o.client_beta, 8) +} + +if o.has_sysid { +res << vproto.pack_uint32_field(o.sysid, 9) +} + +if o.has_allow_webrtc { +res << vproto.pack_bool_field(o.allow_webrtc, 10) +} + +return res +} + +pub fn cbroadcastbeginbroadcastsessionrequest_unpack(buf []byte) ?CBroadcastBeginBroadcastSessionRequest { +mut res := CBroadcastBeginBroadcastSessionRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_permission = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.permission = v +i = ii +} + +2 { +res.has_gameid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.gameid = v +i = ii +} + +3 { +res.has_client_instance_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.client_instance_id = v +i = ii +} + +4 { +res.has_title = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.title = v +i = ii +} + +5 { +res.has_cellid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cellid = v +i = ii +} + +6 { +res.has_rtmp_token = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.rtmp_token = v +i = ii +} + +7 { +res.has_thumbnail_upload = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.thumbnail_upload = v +i = ii +} + +8 { +res.has_client_beta = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.client_beta = v +i = ii +} + +9 { +res.has_sysid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.sysid = v +i = ii +} + +10 { +res.has_allow_webrtc = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.allow_webrtc = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastbeginbroadcastsessionrequest() CBroadcastBeginBroadcastSessionRequest { +return CBroadcastBeginBroadcastSessionRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastbeginbroadcastsessionrequest(o CBroadcastBeginBroadcastSessionRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastbeginbroadcastsessionrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastBeginBroadcastSessionRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastbeginbroadcastsessionrequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastBeginBroadcastSessionResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +broadcast_id u64 +has_broadcast_id bool +thumbnail_upload_address string +has_thumbnail_upload_address bool +thumbnail_upload_token string +has_thumbnail_upload_token bool +thumbnail_interval_seconds u32 +has_thumbnail_interval_seconds bool +heartbeat_interval_seconds u32 +has_heartbeat_interval_seconds bool +} +pub fn (o &CBroadcastBeginBroadcastSessionResponse) pack() []byte { +mut res := []byte{} +if o.has_broadcast_id { +res << vproto.pack_64bit_field(o.broadcast_id, 1) +} + +if o.has_thumbnail_upload_address { +res << vproto.pack_string_field(o.thumbnail_upload_address, 2) +} + +if o.has_thumbnail_upload_token { +res << vproto.pack_string_field(o.thumbnail_upload_token, 3) +} + +if o.has_thumbnail_interval_seconds { +res << vproto.pack_uint32_field(o.thumbnail_interval_seconds, 4) +} + +if o.has_heartbeat_interval_seconds { +res << vproto.pack_uint32_field(o.heartbeat_interval_seconds, 5) +} + +return res +} + +pub fn cbroadcastbeginbroadcastsessionresponse_unpack(buf []byte) ?CBroadcastBeginBroadcastSessionResponse { +mut res := CBroadcastBeginBroadcastSessionResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_broadcast_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_id = v +i = ii +} + +2 { +res.has_thumbnail_upload_address = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.thumbnail_upload_address = v +i = ii +} + +3 { +res.has_thumbnail_upload_token = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.thumbnail_upload_token = v +i = ii +} + +4 { +res.has_thumbnail_interval_seconds = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.thumbnail_interval_seconds = v +i = ii +} + +5 { +res.has_heartbeat_interval_seconds = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.heartbeat_interval_seconds = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastbeginbroadcastsessionresponse() CBroadcastBeginBroadcastSessionResponse { +return CBroadcastBeginBroadcastSessionResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastbeginbroadcastsessionresponse(o CBroadcastBeginBroadcastSessionResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastbeginbroadcastsessionresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastBeginBroadcastSessionResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastbeginbroadcastsessionresponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastEndBroadcastSessionRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +broadcast_id u64 +has_broadcast_id bool +} +pub fn (o &CBroadcastEndBroadcastSessionRequest) pack() []byte { +mut res := []byte{} +if o.has_broadcast_id { +res << vproto.pack_64bit_field(o.broadcast_id, 1) +} + +return res +} + +pub fn cbroadcastendbroadcastsessionrequest_unpack(buf []byte) ?CBroadcastEndBroadcastSessionRequest { +mut res := CBroadcastEndBroadcastSessionRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_broadcast_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastendbroadcastsessionrequest() CBroadcastEndBroadcastSessionRequest { +return CBroadcastEndBroadcastSessionRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastendbroadcastsessionrequest(o CBroadcastEndBroadcastSessionRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastendbroadcastsessionrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastEndBroadcastSessionRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastendbroadcastsessionrequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastEndBroadcastSessionResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CBroadcastEndBroadcastSessionResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cbroadcastendbroadcastsessionresponse_unpack(buf []byte) ?CBroadcastEndBroadcastSessionResponse { +res := CBroadcastEndBroadcastSessionResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastendbroadcastsessionresponse() CBroadcastEndBroadcastSessionResponse { +return CBroadcastEndBroadcastSessionResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastendbroadcastsessionresponse(o CBroadcastEndBroadcastSessionResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastendbroadcastsessionresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastEndBroadcastSessionResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastendbroadcastsessionresponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastStartBroadcastUploadRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +broadcast_id u64 +has_broadcast_id bool +cellid u32 +has_cellid bool +as_rtmp bool +has_as_rtmp bool +delay_seconds u32 +has_delay_seconds bool +rtmp_token u64 +has_rtmp_token bool +upload_ip_address u32 +has_upload_ip_address bool +is_replay bool +has_is_replay bool +sysid u32 +has_sysid bool +} +pub fn (o &CBroadcastStartBroadcastUploadRequest) pack() []byte { +mut res := []byte{} +if o.has_broadcast_id { +res << vproto.pack_64bit_field(o.broadcast_id, 1) +} + +if o.has_cellid { +res << vproto.pack_uint32_field(o.cellid, 2) +} + +if o.has_as_rtmp { +res << vproto.pack_bool_field(o.as_rtmp, 3) +} + +if o.has_delay_seconds { +res << vproto.pack_uint32_field(o.delay_seconds, 4) +} + +if o.has_rtmp_token { +res << vproto.pack_uint64_field(o.rtmp_token, 5) +} + +if o.has_upload_ip_address { +res << vproto.pack_uint32_field(o.upload_ip_address, 6) +} + +if o.has_is_replay { +res << vproto.pack_bool_field(o.is_replay, 7) +} + +if o.has_sysid { +res << vproto.pack_uint32_field(o.sysid, 8) +} + +return res +} + +pub fn cbroadcaststartbroadcastuploadrequest_unpack(buf []byte) ?CBroadcastStartBroadcastUploadRequest { +mut res := CBroadcastStartBroadcastUploadRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_broadcast_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_id = v +i = ii +} + +2 { +res.has_cellid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cellid = v +i = ii +} + +3 { +res.has_as_rtmp = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.as_rtmp = v +i = ii +} + +4 { +res.has_delay_seconds = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.delay_seconds = v +i = ii +} + +5 { +res.has_rtmp_token = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.rtmp_token = v +i = ii +} + +6 { +res.has_upload_ip_address = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.upload_ip_address = v +i = ii +} + +7 { +res.has_is_replay = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_replay = v +i = ii +} + +8 { +res.has_sysid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.sysid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcaststartbroadcastuploadrequest() CBroadcastStartBroadcastUploadRequest { +return CBroadcastStartBroadcastUploadRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcaststartbroadcastuploadrequest(o CBroadcastStartBroadcastUploadRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcaststartbroadcastuploadrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastStartBroadcastUploadRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcaststartbroadcastuploadrequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastStartBroadcastUploadResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +upload_token string +has_upload_token bool +upload_address string +has_upload_address bool +broadcast_upload_id u64 +has_broadcast_upload_id bool +enable_replay bool +has_enable_replay bool +http_address string +has_http_address bool +} +pub fn (o &CBroadcastStartBroadcastUploadResponse) pack() []byte { +mut res := []byte{} +if o.has_upload_token { +res << vproto.pack_string_field(o.upload_token, 1) +} + +if o.has_upload_address { +res << vproto.pack_string_field(o.upload_address, 2) +} + +if o.has_broadcast_upload_id { +res << vproto.pack_64bit_field(o.broadcast_upload_id, 3) +} + +if o.has_enable_replay { +res << vproto.pack_bool_field(o.enable_replay, 6) +} + +if o.has_http_address { +res << vproto.pack_string_field(o.http_address, 7) +} + +return res +} + +pub fn cbroadcaststartbroadcastuploadresponse_unpack(buf []byte) ?CBroadcastStartBroadcastUploadResponse { +mut res := CBroadcastStartBroadcastUploadResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_upload_token = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.upload_token = v +i = ii +} + +2 { +res.has_upload_address = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.upload_address = v +i = ii +} + +3 { +res.has_broadcast_upload_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_upload_id = v +i = ii +} + +6 { +res.has_enable_replay = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enable_replay = v +i = ii +} + +7 { +res.has_http_address = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.http_address = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcaststartbroadcastuploadresponse() CBroadcastStartBroadcastUploadResponse { +return CBroadcastStartBroadcastUploadResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcaststartbroadcastuploadresponse(o CBroadcastStartBroadcastUploadResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcaststartbroadcastuploadresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastStartBroadcastUploadResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcaststartbroadcastuploadresponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastNotifyBroadcastUploadStopNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +broadcast_upload_id u64 +has_broadcast_upload_id bool +upload_result u32 +has_upload_result bool +} +pub fn (o &CBroadcastNotifyBroadcastUploadStopNotification) pack() []byte { +mut res := []byte{} +if o.has_broadcast_upload_id { +res << vproto.pack_64bit_field(o.broadcast_upload_id, 1) +} + +if o.has_upload_result { +res << vproto.pack_uint32_field(o.upload_result, 2) +} + +return res +} + +pub fn cbroadcastnotifybroadcastuploadstopnotification_unpack(buf []byte) ?CBroadcastNotifyBroadcastUploadStopNotification { +mut res := CBroadcastNotifyBroadcastUploadStopNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_broadcast_upload_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_upload_id = v +i = ii +} + +2 { +res.has_upload_result = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.upload_result = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastnotifybroadcastuploadstopnotification() CBroadcastNotifyBroadcastUploadStopNotification { +return CBroadcastNotifyBroadcastUploadStopNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastnotifybroadcastuploadstopnotification(o CBroadcastNotifyBroadcastUploadStopNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastnotifybroadcastuploadstopnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastNotifyBroadcastUploadStopNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastnotifybroadcastuploadstopnotification_unpack(v)? +return i, unpacked +} +pub struct CBroadcastWatchBroadcastRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +existing_broadcast_id u64 +has_existing_broadcast_id bool +viewer_token u64 +has_viewer_token bool +client_ip u32 +has_client_ip bool +client_cell u32 +has_client_cell bool +watch_location EBroadcastWatchLocation +has_watch_location bool +is_webrtc bool +has_is_webrtc bool +} +pub fn (o &CBroadcastWatchBroadcastRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_existing_broadcast_id { +res << vproto.pack_64bit_field(o.existing_broadcast_id, 2) +} + +if o.has_viewer_token { +res << vproto.pack_64bit_field(o.viewer_token, 3) +} + +if o.has_client_ip { +res << vproto.pack_uint32_field(o.client_ip, 4) +} + +if o.has_client_cell { +res << vproto.pack_uint32_field(o.client_cell, 5) +} + +if o.has_watch_location { +res << zzz_vproto_internal_pack_ebroadcastwatchlocation(o.watch_location, 6) +} + +if o.has_is_webrtc { +res << vproto.pack_bool_field(o.is_webrtc, 7) +} + +return res +} + +pub fn cbroadcastwatchbroadcastrequest_unpack(buf []byte) ?CBroadcastWatchBroadcastRequest { +mut res := CBroadcastWatchBroadcastRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_existing_broadcast_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.existing_broadcast_id = v +i = ii +} + +3 { +res.has_viewer_token = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.viewer_token = v +i = ii +} + +4 { +res.has_client_ip = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.client_ip = v +i = ii +} + +5 { +res.has_client_cell = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.client_cell = v +i = ii +} + +6 { +res.has_watch_location = true +ii, v := zzz_vproto_internal_unpack_ebroadcastwatchlocation(cur_buf, tag_wiretype.wire_type)? +res.watch_location = v +i = ii +} + +7 { +res.has_is_webrtc = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_webrtc = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastwatchbroadcastrequest() CBroadcastWatchBroadcastRequest { +return CBroadcastWatchBroadcastRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastwatchbroadcastrequest(o CBroadcastWatchBroadcastRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastwatchbroadcastrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastWatchBroadcastRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastwatchbroadcastrequest_unpack(v)? +return i, unpacked +} +[_allow_multiple_values] +enum CBroadcastWatchBroadcastResponseEWatchResponse { +k_ewatchresponseready = 1 +k_ewatchresponsenotavailable = 2 +k_ewatchresponsewaitingforapproval = 3 +k_ewatchresponsewaitingforstart = 4 +k_ewatchresponseinvalidsession = 5 +k_ewatchresponsetoomanybroadcasts = 6 +k_ewatchresponsewaitingforreconnect = 7 +k_ewatchresponsesystemnotsupported = 8 +k_ewatchresponseuserrestricted = 9 +k_ewatchresponseclientoutofdate = 10 +k_ewatchresponsepooruploadquality = 11 +k_ewatchresponsemissingsubscription = 12 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_cbroadcastwatchbroadcastresponseewatchresponse(e CBroadcastWatchBroadcastResponseEWatchResponse, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_cbroadcastwatchbroadcastresponseewatchresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastWatchBroadcastResponseEWatchResponse) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, CBroadcastWatchBroadcastResponseEWatchResponse(v) +} +pub struct CBroadcastWatchBroadcastResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +response CBroadcastWatchBroadcastResponseEWatchResponse +has_response bool +mpd_url string +has_mpd_url bool +broadcast_id u64 +has_broadcast_id bool +gameid u64 +has_gameid bool +title string +has_title bool +num_viewers u32 +has_num_viewers bool +permission int +has_permission bool +is_rtmp bool +has_is_rtmp bool +seconds_delay int +has_seconds_delay bool +viewer_token u64 +has_viewer_token bool +hls_m3u8_master_url string +has_hls_m3u8_master_url bool +heartbeat_interval int +has_heartbeat_interval bool +thumbnail_url string +has_thumbnail_url bool +is_webrtc bool +has_is_webrtc bool +webrtc_session_id u64 +has_webrtc_session_id bool +webrtc_offer_sdp string +has_webrtc_offer_sdp bool +webrtc_turn_server string +has_webrtc_turn_server bool +is_replay bool +has_is_replay bool +duration int +has_duration bool +} +pub fn (o &CBroadcastWatchBroadcastResponse) pack() []byte { +mut res := []byte{} +if o.has_response { +res << zzz_vproto_internal_pack_cbroadcastwatchbroadcastresponseewatchresponse(o.response, 1) +} + +if o.has_mpd_url { +res << vproto.pack_string_field(o.mpd_url, 2) +} + +if o.has_broadcast_id { +res << vproto.pack_64bit_field(o.broadcast_id, 3) +} + +if o.has_gameid { +res << vproto.pack_uint64_field(o.gameid, 4) +} + +if o.has_title { +res << vproto.pack_string_field(o.title, 5) +} + +if o.has_num_viewers { +res << vproto.pack_uint32_field(o.num_viewers, 6) +} + +if o.has_permission { +res << vproto.pack_int32_field(o.permission, 7) +} + +if o.has_is_rtmp { +res << vproto.pack_bool_field(o.is_rtmp, 8) +} + +if o.has_seconds_delay { +res << vproto.pack_int32_field(o.seconds_delay, 9) +} + +if o.has_viewer_token { +res << vproto.pack_64bit_field(o.viewer_token, 10) +} + +if o.has_hls_m3u8_master_url { +res << vproto.pack_string_field(o.hls_m3u8_master_url, 11) +} + +if o.has_heartbeat_interval { +res << vproto.pack_int32_field(o.heartbeat_interval, 12) +} + +if o.has_thumbnail_url { +res << vproto.pack_string_field(o.thumbnail_url, 13) +} + +if o.has_is_webrtc { +res << vproto.pack_bool_field(o.is_webrtc, 14) +} + +if o.has_webrtc_session_id { +res << vproto.pack_64bit_field(o.webrtc_session_id, 15) +} + +if o.has_webrtc_offer_sdp { +res << vproto.pack_string_field(o.webrtc_offer_sdp, 16) +} + +if o.has_webrtc_turn_server { +res << vproto.pack_string_field(o.webrtc_turn_server, 17) +} + +if o.has_is_replay { +res << vproto.pack_bool_field(o.is_replay, 18) +} + +if o.has_duration { +res << vproto.pack_int32_field(o.duration, 19) +} + +return res +} + +pub fn cbroadcastwatchbroadcastresponse_unpack(buf []byte) ?CBroadcastWatchBroadcastResponse { +mut res := CBroadcastWatchBroadcastResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_response = true +ii, v := zzz_vproto_internal_unpack_cbroadcastwatchbroadcastresponseewatchresponse(cur_buf, tag_wiretype.wire_type)? +res.response = v +i = ii +} + +2 { +res.has_mpd_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.mpd_url = v +i = ii +} + +3 { +res.has_broadcast_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_id = v +i = ii +} + +4 { +res.has_gameid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.gameid = v +i = ii +} + +5 { +res.has_title = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.title = v +i = ii +} + +6 { +res.has_num_viewers = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.num_viewers = v +i = ii +} + +7 { +res.has_permission = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.permission = v +i = ii +} + +8 { +res.has_is_rtmp = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_rtmp = v +i = ii +} + +9 { +res.has_seconds_delay = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_delay = v +i = ii +} + +10 { +res.has_viewer_token = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.viewer_token = v +i = ii +} + +11 { +res.has_hls_m3u8_master_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.hls_m3u8_master_url = v +i = ii +} + +12 { +res.has_heartbeat_interval = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.heartbeat_interval = v +i = ii +} + +13 { +res.has_thumbnail_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.thumbnail_url = v +i = ii +} + +14 { +res.has_is_webrtc = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_webrtc = v +i = ii +} + +15 { +res.has_webrtc_session_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.webrtc_session_id = v +i = ii +} + +16 { +res.has_webrtc_offer_sdp = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.webrtc_offer_sdp = v +i = ii +} + +17 { +res.has_webrtc_turn_server = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.webrtc_turn_server = v +i = ii +} + +18 { +res.has_is_replay = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_replay = v +i = ii +} + +19 { +res.has_duration = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.duration = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastwatchbroadcastresponse() CBroadcastWatchBroadcastResponse { +return CBroadcastWatchBroadcastResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastwatchbroadcastresponse(o CBroadcastWatchBroadcastResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastwatchbroadcastresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastWatchBroadcastResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastwatchbroadcastresponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastHeartbeatBroadcastNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +broadcast_id u64 +has_broadcast_id bool +viewer_token u64 +has_viewer_token bool +representation u32 +has_representation bool +} +pub fn (o &CBroadcastHeartbeatBroadcastNotification) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_broadcast_id { +res << vproto.pack_64bit_field(o.broadcast_id, 2) +} + +if o.has_viewer_token { +res << vproto.pack_64bit_field(o.viewer_token, 3) +} + +if o.has_representation { +res << vproto.pack_uint32_field(o.representation, 4) +} + +return res +} + +pub fn cbroadcastheartbeatbroadcastnotification_unpack(buf []byte) ?CBroadcastHeartbeatBroadcastNotification { +mut res := CBroadcastHeartbeatBroadcastNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_broadcast_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_id = v +i = ii +} + +3 { +res.has_viewer_token = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.viewer_token = v +i = ii +} + +4 { +res.has_representation = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.representation = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastheartbeatbroadcastnotification() CBroadcastHeartbeatBroadcastNotification { +return CBroadcastHeartbeatBroadcastNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastheartbeatbroadcastnotification(o CBroadcastHeartbeatBroadcastNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastheartbeatbroadcastnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastHeartbeatBroadcastNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastheartbeatbroadcastnotification_unpack(v)? +return i, unpacked +} +pub struct CBroadcastStopWatchingBroadcastNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +broadcast_id u64 +has_broadcast_id bool +viewer_token u64 +has_viewer_token bool +} +pub fn (o &CBroadcastStopWatchingBroadcastNotification) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_broadcast_id { +res << vproto.pack_64bit_field(o.broadcast_id, 2) +} + +if o.has_viewer_token { +res << vproto.pack_64bit_field(o.viewer_token, 3) +} + +return res +} + +pub fn cbroadcaststopwatchingbroadcastnotification_unpack(buf []byte) ?CBroadcastStopWatchingBroadcastNotification { +mut res := CBroadcastStopWatchingBroadcastNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_broadcast_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_id = v +i = ii +} + +3 { +res.has_viewer_token = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.viewer_token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcaststopwatchingbroadcastnotification() CBroadcastStopWatchingBroadcastNotification { +return CBroadcastStopWatchingBroadcastNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcaststopwatchingbroadcastnotification(o CBroadcastStopWatchingBroadcastNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcaststopwatchingbroadcastnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastStopWatchingBroadcastNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcaststopwatchingbroadcastnotification_unpack(v)? +return i, unpacked +} +pub struct CBroadcastGetBroadcastStatusRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +broadcast_id u64 +has_broadcast_id bool +} +pub fn (o &CBroadcastGetBroadcastStatusRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_broadcast_id { +res << vproto.pack_64bit_field(o.broadcast_id, 2) +} + +return res +} + +pub fn cbroadcastgetbroadcaststatusrequest_unpack(buf []byte) ?CBroadcastGetBroadcastStatusRequest { +mut res := CBroadcastGetBroadcastStatusRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_broadcast_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastgetbroadcaststatusrequest() CBroadcastGetBroadcastStatusRequest { +return CBroadcastGetBroadcastStatusRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastgetbroadcaststatusrequest(o CBroadcastGetBroadcastStatusRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastgetbroadcaststatusrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastGetBroadcastStatusRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastgetbroadcaststatusrequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastGetBroadcastStatusResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +gameid u64 +has_gameid bool +title string +has_title bool +num_viewers u32 +has_num_viewers bool +permission int +has_permission bool +is_rtmp bool +has_is_rtmp bool +seconds_delay int +has_seconds_delay bool +is_publisher bool +has_is_publisher bool +thumbnail_url string +has_thumbnail_url bool +update_interval int +has_update_interval bool +is_uploading bool +has_is_uploading bool +duration u32 +has_duration bool +is_replay bool +has_is_replay bool +is_capturing_vod bool +has_is_capturing_vod bool +is_store_whitelisted bool +has_is_store_whitelisted bool +} +pub fn (o &CBroadcastGetBroadcastStatusResponse) pack() []byte { +mut res := []byte{} +if o.has_gameid { +res << vproto.pack_uint64_field(o.gameid, 1) +} + +if o.has_title { +res << vproto.pack_string_field(o.title, 2) +} + +if o.has_num_viewers { +res << vproto.pack_uint32_field(o.num_viewers, 3) +} + +if o.has_permission { +res << vproto.pack_int32_field(o.permission, 4) +} + +if o.has_is_rtmp { +res << vproto.pack_bool_field(o.is_rtmp, 5) +} + +if o.has_seconds_delay { +res << vproto.pack_int32_field(o.seconds_delay, 6) +} + +if o.has_is_publisher { +res << vproto.pack_bool_field(o.is_publisher, 7) +} + +if o.has_thumbnail_url { +res << vproto.pack_string_field(o.thumbnail_url, 8) +} + +if o.has_update_interval { +res << vproto.pack_int32_field(o.update_interval, 9) +} + +if o.has_is_uploading { +res << vproto.pack_bool_field(o.is_uploading, 10) +} + +if o.has_duration { +res << vproto.pack_uint32_field(o.duration, 11) +} + +if o.has_is_replay { +res << vproto.pack_bool_field(o.is_replay, 12) +} + +if o.has_is_capturing_vod { +res << vproto.pack_bool_field(o.is_capturing_vod, 13) +} + +if o.has_is_store_whitelisted { +res << vproto.pack_bool_field(o.is_store_whitelisted, 14) +} + +return res +} + +pub fn cbroadcastgetbroadcaststatusresponse_unpack(buf []byte) ?CBroadcastGetBroadcastStatusResponse { +mut res := CBroadcastGetBroadcastStatusResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_gameid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.gameid = v +i = ii +} + +2 { +res.has_title = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.title = v +i = ii +} + +3 { +res.has_num_viewers = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.num_viewers = v +i = ii +} + +4 { +res.has_permission = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.permission = v +i = ii +} + +5 { +res.has_is_rtmp = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_rtmp = v +i = ii +} + +6 { +res.has_seconds_delay = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_delay = v +i = ii +} + +7 { +res.has_is_publisher = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_publisher = v +i = ii +} + +8 { +res.has_thumbnail_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.thumbnail_url = v +i = ii +} + +9 { +res.has_update_interval = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.update_interval = v +i = ii +} + +10 { +res.has_is_uploading = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_uploading = v +i = ii +} + +11 { +res.has_duration = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.duration = v +i = ii +} + +12 { +res.has_is_replay = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_replay = v +i = ii +} + +13 { +res.has_is_capturing_vod = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_capturing_vod = v +i = ii +} + +14 { +res.has_is_store_whitelisted = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_store_whitelisted = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastgetbroadcaststatusresponse() CBroadcastGetBroadcastStatusResponse { +return CBroadcastGetBroadcastStatusResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastgetbroadcaststatusresponse(o CBroadcastGetBroadcastStatusResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastgetbroadcaststatusresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastGetBroadcastStatusResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastgetbroadcaststatusresponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastGetBroadcastThumbnailRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +broadcast_id u64 +has_broadcast_id bool +} +pub fn (o &CBroadcastGetBroadcastThumbnailRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_broadcast_id { +res << vproto.pack_64bit_field(o.broadcast_id, 2) +} + +return res +} + +pub fn cbroadcastgetbroadcastthumbnailrequest_unpack(buf []byte) ?CBroadcastGetBroadcastThumbnailRequest { +mut res := CBroadcastGetBroadcastThumbnailRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_broadcast_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastgetbroadcastthumbnailrequest() CBroadcastGetBroadcastThumbnailRequest { +return CBroadcastGetBroadcastThumbnailRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastgetbroadcastthumbnailrequest(o CBroadcastGetBroadcastThumbnailRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastgetbroadcastthumbnailrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastGetBroadcastThumbnailRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastgetbroadcastthumbnailrequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastGetBroadcastThumbnailResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +thumbnail_url string +has_thumbnail_url bool +update_interval int +has_update_interval bool +num_viewers int +has_num_viewers bool +duration int +has_duration bool +} +pub fn (o &CBroadcastGetBroadcastThumbnailResponse) pack() []byte { +mut res := []byte{} +if o.has_thumbnail_url { +res << vproto.pack_string_field(o.thumbnail_url, 1) +} + +if o.has_update_interval { +res << vproto.pack_int32_field(o.update_interval, 2) +} + +if o.has_num_viewers { +res << vproto.pack_int32_field(o.num_viewers, 3) +} + +if o.has_duration { +res << vproto.pack_int32_field(o.duration, 4) +} + +return res +} + +pub fn cbroadcastgetbroadcastthumbnailresponse_unpack(buf []byte) ?CBroadcastGetBroadcastThumbnailResponse { +mut res := CBroadcastGetBroadcastThumbnailResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_thumbnail_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.thumbnail_url = v +i = ii +} + +2 { +res.has_update_interval = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.update_interval = v +i = ii +} + +3 { +res.has_num_viewers = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.num_viewers = v +i = ii +} + +4 { +res.has_duration = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.duration = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastgetbroadcastthumbnailresponse() CBroadcastGetBroadcastThumbnailResponse { +return CBroadcastGetBroadcastThumbnailResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastgetbroadcastthumbnailresponse(o CBroadcastGetBroadcastThumbnailResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastgetbroadcastthumbnailresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastGetBroadcastThumbnailResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastgetbroadcastthumbnailresponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastInviteToBroadcastRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +approval_response bool +has_approval_response bool +} +pub fn (o &CBroadcastInviteToBroadcastRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_approval_response { +res << vproto.pack_bool_field(o.approval_response, 2) +} + +return res +} + +pub fn cbroadcastinvitetobroadcastrequest_unpack(buf []byte) ?CBroadcastInviteToBroadcastRequest { +mut res := CBroadcastInviteToBroadcastRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_approval_response = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.approval_response = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastinvitetobroadcastrequest() CBroadcastInviteToBroadcastRequest { +return CBroadcastInviteToBroadcastRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastinvitetobroadcastrequest(o CBroadcastInviteToBroadcastRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastinvitetobroadcastrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastInviteToBroadcastRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastinvitetobroadcastrequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastInviteToBroadcastResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +success bool +has_success bool +} +pub fn (o &CBroadcastInviteToBroadcastResponse) pack() []byte { +mut res := []byte{} +if o.has_success { +res << vproto.pack_bool_field(o.success, 1) +} + +return res +} + +pub fn cbroadcastinvitetobroadcastresponse_unpack(buf []byte) ?CBroadcastInviteToBroadcastResponse { +mut res := CBroadcastInviteToBroadcastResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_success = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.success = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastinvitetobroadcastresponse() CBroadcastInviteToBroadcastResponse { +return CBroadcastInviteToBroadcastResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastinvitetobroadcastresponse(o CBroadcastInviteToBroadcastResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastinvitetobroadcastresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastInviteToBroadcastResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastinvitetobroadcastresponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastSendBroadcastStateToServerRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +permission int +has_permission bool +gameid u64 +has_gameid bool +title string +has_title bool +game_data_config string +has_game_data_config bool +} +pub fn (o &CBroadcastSendBroadcastStateToServerRequest) pack() []byte { +mut res := []byte{} +if o.has_permission { +res << vproto.pack_int32_field(o.permission, 1) +} + +if o.has_gameid { +res << vproto.pack_uint64_field(o.gameid, 2) +} + +if o.has_title { +res << vproto.pack_string_field(o.title, 3) +} + +if o.has_game_data_config { +res << vproto.pack_string_field(o.game_data_config, 4) +} + +return res +} + +pub fn cbroadcastsendbroadcaststatetoserverrequest_unpack(buf []byte) ?CBroadcastSendBroadcastStateToServerRequest { +mut res := CBroadcastSendBroadcastStateToServerRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_permission = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.permission = v +i = ii +} + +2 { +res.has_gameid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.gameid = v +i = ii +} + +3 { +res.has_title = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.title = v +i = ii +} + +4 { +res.has_game_data_config = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.game_data_config = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastsendbroadcaststatetoserverrequest() CBroadcastSendBroadcastStateToServerRequest { +return CBroadcastSendBroadcastStateToServerRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastsendbroadcaststatetoserverrequest(o CBroadcastSendBroadcastStateToServerRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastsendbroadcaststatetoserverrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastSendBroadcastStateToServerRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastsendbroadcaststatetoserverrequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastSendBroadcastStateToServerResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CBroadcastSendBroadcastStateToServerResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cbroadcastsendbroadcaststatetoserverresponse_unpack(buf []byte) ?CBroadcastSendBroadcastStateToServerResponse { +res := CBroadcastSendBroadcastStateToServerResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastsendbroadcaststatetoserverresponse() CBroadcastSendBroadcastStateToServerResponse { +return CBroadcastSendBroadcastStateToServerResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastsendbroadcaststatetoserverresponse(o CBroadcastSendBroadcastStateToServerResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastsendbroadcaststatetoserverresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastSendBroadcastStateToServerResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastsendbroadcaststatetoserverresponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastNotifyBroadcastSessionHeartbeatNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +broadcast_id u64 +has_broadcast_id bool +} +pub fn (o &CBroadcastNotifyBroadcastSessionHeartbeatNotification) pack() []byte { +mut res := []byte{} +if o.has_broadcast_id { +res << vproto.pack_64bit_field(o.broadcast_id, 1) +} + +return res +} + +pub fn cbroadcastnotifybroadcastsessionheartbeatnotification_unpack(buf []byte) ?CBroadcastNotifyBroadcastSessionHeartbeatNotification { +mut res := CBroadcastNotifyBroadcastSessionHeartbeatNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_broadcast_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastnotifybroadcastsessionheartbeatnotification() CBroadcastNotifyBroadcastSessionHeartbeatNotification { +return CBroadcastNotifyBroadcastSessionHeartbeatNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastnotifybroadcastsessionheartbeatnotification(o CBroadcastNotifyBroadcastSessionHeartbeatNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastnotifybroadcastsessionheartbeatnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastNotifyBroadcastSessionHeartbeatNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastnotifybroadcastsessionheartbeatnotification_unpack(v)? +return i, unpacked +} +pub struct CBroadcastGetBroadcastChatInfoRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +broadcast_id u64 +has_broadcast_id bool +client_ip u32 +has_client_ip bool +client_cell u32 +has_client_cell bool +} +pub fn (o &CBroadcastGetBroadcastChatInfoRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_broadcast_id { +res << vproto.pack_64bit_field(o.broadcast_id, 2) +} + +if o.has_client_ip { +res << vproto.pack_uint32_field(o.client_ip, 3) +} + +if o.has_client_cell { +res << vproto.pack_uint32_field(o.client_cell, 4) +} + +return res +} + +pub fn cbroadcastgetbroadcastchatinforequest_unpack(buf []byte) ?CBroadcastGetBroadcastChatInfoRequest { +mut res := CBroadcastGetBroadcastChatInfoRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_broadcast_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_id = v +i = ii +} + +3 { +res.has_client_ip = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.client_ip = v +i = ii +} + +4 { +res.has_client_cell = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.client_cell = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastgetbroadcastchatinforequest() CBroadcastGetBroadcastChatInfoRequest { +return CBroadcastGetBroadcastChatInfoRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastgetbroadcastchatinforequest(o CBroadcastGetBroadcastChatInfoRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastgetbroadcastchatinforequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastGetBroadcastChatInfoRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastgetbroadcastchatinforequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastGetBroadcastChatInfoResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_id u64 +has_chat_id bool +view_url_template string +has_view_url_template bool +flair_group_ids []u32 +} +pub fn (o &CBroadcastGetBroadcastChatInfoResponse) pack() []byte { +mut res := []byte{} +if o.has_chat_id { +res << vproto.pack_64bit_field(o.chat_id, 1) +} + +if o.has_view_url_template { +res << vproto.pack_string_field(o.view_url_template, 3) +} + +// [packed=false] +for _, x in o.flair_group_ids { +res << vproto.pack_uint32_field(x, 4) +} + +return res +} + +pub fn cbroadcastgetbroadcastchatinforesponse_unpack(buf []byte) ?CBroadcastGetBroadcastChatInfoResponse { +mut res := CBroadcastGetBroadcastChatInfoResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +3 { +res.has_view_url_template = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.view_url_template = v +i = ii +} + +4 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.flair_group_ids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastgetbroadcastchatinforesponse() CBroadcastGetBroadcastChatInfoResponse { +return CBroadcastGetBroadcastChatInfoResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastgetbroadcastchatinforesponse(o CBroadcastGetBroadcastChatInfoResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastgetbroadcastchatinforesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastGetBroadcastChatInfoResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastgetbroadcastchatinforesponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastPostChatMessageRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_id u64 +has_chat_id bool +message string +has_message bool +instance_id u32 +has_instance_id bool +language u32 +has_language bool +country_code string +has_country_code bool +} +pub fn (o &CBroadcastPostChatMessageRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_id { +res << vproto.pack_64bit_field(o.chat_id, 1) +} + +if o.has_message { +res << vproto.pack_string_field(o.message, 2) +} + +if o.has_instance_id { +res << vproto.pack_uint32_field(o.instance_id, 3) +} + +if o.has_language { +res << vproto.pack_uint32_field(o.language, 4) +} + +if o.has_country_code { +res << vproto.pack_string_field(o.country_code, 5) +} + +return res +} + +pub fn cbroadcastpostchatmessagerequest_unpack(buf []byte) ?CBroadcastPostChatMessageRequest { +mut res := CBroadcastPostChatMessageRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +2 { +res.has_message = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.message = v +i = ii +} + +3 { +res.has_instance_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.instance_id = v +i = ii +} + +4 { +res.has_language = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +5 { +res.has_country_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.country_code = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastpostchatmessagerequest() CBroadcastPostChatMessageRequest { +return CBroadcastPostChatMessageRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastpostchatmessagerequest(o CBroadcastPostChatMessageRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastpostchatmessagerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastPostChatMessageRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastpostchatmessagerequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastPostChatMessageResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +persona_name string +has_persona_name bool +in_game bool +has_in_game bool +result int +has_result bool +cooldown_time_seconds int +has_cooldown_time_seconds bool +} +pub fn (o &CBroadcastPostChatMessageResponse) pack() []byte { +mut res := []byte{} +if o.has_persona_name { +res << vproto.pack_string_field(o.persona_name, 1) +} + +if o.has_in_game { +res << vproto.pack_bool_field(o.in_game, 2) +} + +if o.has_result { +res << vproto.pack_int32_field(o.result, 3) +} + +if o.has_cooldown_time_seconds { +res << vproto.pack_int32_field(o.cooldown_time_seconds, 4) +} + +return res +} + +pub fn cbroadcastpostchatmessageresponse_unpack(buf []byte) ?CBroadcastPostChatMessageResponse { +mut res := CBroadcastPostChatMessageResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_persona_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.persona_name = v +i = ii +} + +2 { +res.has_in_game = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.in_game = v +i = ii +} + +3 { +res.has_result = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.result = v +i = ii +} + +4 { +res.has_cooldown_time_seconds = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.cooldown_time_seconds = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastpostchatmessageresponse() CBroadcastPostChatMessageResponse { +return CBroadcastPostChatMessageResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastpostchatmessageresponse(o CBroadcastPostChatMessageResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastpostchatmessageresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastPostChatMessageResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastpostchatmessageresponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastUpdateChatMessageFlairRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_id u64 +has_chat_id bool +flair string +has_flair bool +} +pub fn (o &CBroadcastUpdateChatMessageFlairRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_id { +res << vproto.pack_64bit_field(o.chat_id, 1) +} + +if o.has_flair { +res << vproto.pack_string_field(o.flair, 2) +} + +return res +} + +pub fn cbroadcastupdatechatmessageflairrequest_unpack(buf []byte) ?CBroadcastUpdateChatMessageFlairRequest { +mut res := CBroadcastUpdateChatMessageFlairRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +2 { +res.has_flair = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.flair = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastupdatechatmessageflairrequest() CBroadcastUpdateChatMessageFlairRequest { +return CBroadcastUpdateChatMessageFlairRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastupdatechatmessageflairrequest(o CBroadcastUpdateChatMessageFlairRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastupdatechatmessageflairrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastUpdateChatMessageFlairRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastupdatechatmessageflairrequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastUpdateChatMessageFlairResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +result int +has_result bool +chat_id u64 +has_chat_id bool +flair string +has_flair bool +} +pub fn (o &CBroadcastUpdateChatMessageFlairResponse) pack() []byte { +mut res := []byte{} +if o.has_result { +res << vproto.pack_int32_field(o.result, 1) +} + +if o.has_chat_id { +res << vproto.pack_64bit_field(o.chat_id, 2) +} + +if o.has_flair { +res << vproto.pack_string_field(o.flair, 3) +} + +return res +} + +pub fn cbroadcastupdatechatmessageflairresponse_unpack(buf []byte) ?CBroadcastUpdateChatMessageFlairResponse { +mut res := CBroadcastUpdateChatMessageFlairResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_result = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.result = v +i = ii +} + +2 { +res.has_chat_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +3 { +res.has_flair = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.flair = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastupdatechatmessageflairresponse() CBroadcastUpdateChatMessageFlairResponse { +return CBroadcastUpdateChatMessageFlairResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastupdatechatmessageflairresponse(o CBroadcastUpdateChatMessageFlairResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastupdatechatmessageflairresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastUpdateChatMessageFlairResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastupdatechatmessageflairresponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastMuteBroadcastChatUserRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_id u64 +has_chat_id bool +user_steamid u64 +has_user_steamid bool +muted bool +has_muted bool +} +pub fn (o &CBroadcastMuteBroadcastChatUserRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_id { +res << vproto.pack_64bit_field(o.chat_id, 1) +} + +if o.has_user_steamid { +res << vproto.pack_64bit_field(o.user_steamid, 2) +} + +if o.has_muted { +res << vproto.pack_bool_field(o.muted, 3) +} + +return res +} + +pub fn cbroadcastmutebroadcastchatuserrequest_unpack(buf []byte) ?CBroadcastMuteBroadcastChatUserRequest { +mut res := CBroadcastMuteBroadcastChatUserRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +2 { +res.has_user_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.user_steamid = v +i = ii +} + +3 { +res.has_muted = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.muted = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastmutebroadcastchatuserrequest() CBroadcastMuteBroadcastChatUserRequest { +return CBroadcastMuteBroadcastChatUserRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastmutebroadcastchatuserrequest(o CBroadcastMuteBroadcastChatUserRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastmutebroadcastchatuserrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastMuteBroadcastChatUserRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastmutebroadcastchatuserrequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastMuteBroadcastChatUserResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CBroadcastMuteBroadcastChatUserResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cbroadcastmutebroadcastchatuserresponse_unpack(buf []byte) ?CBroadcastMuteBroadcastChatUserResponse { +res := CBroadcastMuteBroadcastChatUserResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastmutebroadcastchatuserresponse() CBroadcastMuteBroadcastChatUserResponse { +return CBroadcastMuteBroadcastChatUserResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastmutebroadcastchatuserresponse(o CBroadcastMuteBroadcastChatUserResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastmutebroadcastchatuserresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastMuteBroadcastChatUserResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastmutebroadcastchatuserresponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastRemoveUserChatTextRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_id u64 +has_chat_id bool +user_steamid u64 +has_user_steamid bool +} +pub fn (o &CBroadcastRemoveUserChatTextRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_id { +res << vproto.pack_64bit_field(o.chat_id, 1) +} + +if o.has_user_steamid { +res << vproto.pack_64bit_field(o.user_steamid, 2) +} + +return res +} + +pub fn cbroadcastremoveuserchattextrequest_unpack(buf []byte) ?CBroadcastRemoveUserChatTextRequest { +mut res := CBroadcastRemoveUserChatTextRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +2 { +res.has_user_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.user_steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastremoveuserchattextrequest() CBroadcastRemoveUserChatTextRequest { +return CBroadcastRemoveUserChatTextRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastremoveuserchattextrequest(o CBroadcastRemoveUserChatTextRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastremoveuserchattextrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastRemoveUserChatTextRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastremoveuserchattextrequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastRemoveUserChatTextResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CBroadcastRemoveUserChatTextResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cbroadcastremoveuserchattextresponse_unpack(buf []byte) ?CBroadcastRemoveUserChatTextResponse { +res := CBroadcastRemoveUserChatTextResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastremoveuserchattextresponse() CBroadcastRemoveUserChatTextResponse { +return CBroadcastRemoveUserChatTextResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastremoveuserchattextresponse(o CBroadcastRemoveUserChatTextResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastremoveuserchattextresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastRemoveUserChatTextResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastremoveuserchattextresponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastGetBroadcastChatUserNamesRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_id u64 +has_chat_id bool +user_steamid []u64 +} +pub fn (o &CBroadcastGetBroadcastChatUserNamesRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_id { +res << vproto.pack_64bit_field(o.chat_id, 1) +} + +// [packed=false] +for _, x in o.user_steamid { +res << vproto.pack_64bit_field(x, 2) +} + +return res +} + +pub fn cbroadcastgetbroadcastchatusernamesrequest_unpack(buf []byte) ?CBroadcastGetBroadcastChatUserNamesRequest { +mut res := CBroadcastGetBroadcastChatUserNamesRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.user_steamid << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastgetbroadcastchatusernamesrequest() CBroadcastGetBroadcastChatUserNamesRequest { +return CBroadcastGetBroadcastChatUserNamesRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastgetbroadcastchatusernamesrequest(o CBroadcastGetBroadcastChatUserNamesRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastgetbroadcastchatusernamesrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastGetBroadcastChatUserNamesRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastgetbroadcastchatusernamesrequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastGetBroadcastChatUserNamesResponsePersonaName { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id u64 +has_steam_id bool +persona string +has_persona bool +} +pub fn (o &CBroadcastGetBroadcastChatUserNamesResponsePersonaName) pack() []byte { +mut res := []byte{} +if o.has_steam_id { +res << vproto.pack_64bit_field(o.steam_id, 1) +} + +if o.has_persona { +res << vproto.pack_string_field(o.persona, 2) +} + +return res +} + +pub fn cbroadcastgetbroadcastchatusernamesresponsepersonaname_unpack(buf []byte) ?CBroadcastGetBroadcastChatUserNamesResponsePersonaName { +mut res := CBroadcastGetBroadcastChatUserNamesResponsePersonaName{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id = v +i = ii +} + +2 { +res.has_persona = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.persona = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastgetbroadcastchatusernamesresponsepersonaname() CBroadcastGetBroadcastChatUserNamesResponsePersonaName { +return CBroadcastGetBroadcastChatUserNamesResponsePersonaName{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastgetbroadcastchatusernamesresponsepersonaname(o CBroadcastGetBroadcastChatUserNamesResponsePersonaName, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastgetbroadcastchatusernamesresponsepersonaname(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastGetBroadcastChatUserNamesResponsePersonaName) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastgetbroadcastchatusernamesresponsepersonaname_unpack(v)? +return i, unpacked +} +pub struct CBroadcastGetBroadcastChatUserNamesResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +persona_names []CBroadcastGetBroadcastChatUserNamesResponsePersonaName +} +pub fn (o &CBroadcastGetBroadcastChatUserNamesResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.persona_names { +res << zzz_vproto_internal_pack_cbroadcastgetbroadcastchatusernamesresponsepersonaname(x, 1) +} + +return res +} + +pub fn cbroadcastgetbroadcastchatusernamesresponse_unpack(buf []byte) ?CBroadcastGetBroadcastChatUserNamesResponse { +mut res := CBroadcastGetBroadcastChatUserNamesResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cbroadcastgetbroadcastchatusernamesresponsepersonaname(cur_buf, tag_wiretype.wire_type)? +res.persona_names << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastgetbroadcastchatusernamesresponse() CBroadcastGetBroadcastChatUserNamesResponse { +return CBroadcastGetBroadcastChatUserNamesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastgetbroadcastchatusernamesresponse(o CBroadcastGetBroadcastChatUserNamesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastgetbroadcastchatusernamesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastGetBroadcastChatUserNamesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastgetbroadcastchatusernamesresponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastStartBuildClipRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +broadcast_session_id u64 +has_broadcast_session_id bool +first_segment int +has_first_segment bool +num_segments int +has_num_segments bool +clip_description string +has_clip_description bool +} +pub fn (o &CBroadcastStartBuildClipRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_broadcast_session_id { +res << vproto.pack_64bit_field(o.broadcast_session_id, 2) +} + +if o.has_first_segment { +res << vproto.pack_int32_field(o.first_segment, 3) +} + +if o.has_num_segments { +res << vproto.pack_int32_field(o.num_segments, 4) +} + +if o.has_clip_description { +res << vproto.pack_string_field(o.clip_description, 5) +} + +return res +} + +pub fn cbroadcaststartbuildcliprequest_unpack(buf []byte) ?CBroadcastStartBuildClipRequest { +mut res := CBroadcastStartBuildClipRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_broadcast_session_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_session_id = v +i = ii +} + +3 { +res.has_first_segment = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.first_segment = v +i = ii +} + +4 { +res.has_num_segments = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.num_segments = v +i = ii +} + +5 { +res.has_clip_description = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.clip_description = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcaststartbuildcliprequest() CBroadcastStartBuildClipRequest { +return CBroadcastStartBuildClipRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcaststartbuildcliprequest(o CBroadcastStartBuildClipRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcaststartbuildcliprequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastStartBuildClipRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcaststartbuildcliprequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastStartBuildClipResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +broadcast_clip_id u64 +has_broadcast_clip_id bool +} +pub fn (o &CBroadcastStartBuildClipResponse) pack() []byte { +mut res := []byte{} +if o.has_broadcast_clip_id { +res << vproto.pack_64bit_field(o.broadcast_clip_id, 1) +} + +return res +} + +pub fn cbroadcaststartbuildclipresponse_unpack(buf []byte) ?CBroadcastStartBuildClipResponse { +mut res := CBroadcastStartBuildClipResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_broadcast_clip_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_clip_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcaststartbuildclipresponse() CBroadcastStartBuildClipResponse { +return CBroadcastStartBuildClipResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcaststartbuildclipresponse(o CBroadcastStartBuildClipResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcaststartbuildclipresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastStartBuildClipResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcaststartbuildclipresponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastGetBuildClipStatusRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +broadcast_clip_id u64 +has_broadcast_clip_id bool +} +pub fn (o &CBroadcastGetBuildClipStatusRequest) pack() []byte { +mut res := []byte{} +if o.has_broadcast_clip_id { +res << vproto.pack_64bit_field(o.broadcast_clip_id, 1) +} + +return res +} + +pub fn cbroadcastgetbuildclipstatusrequest_unpack(buf []byte) ?CBroadcastGetBuildClipStatusRequest { +mut res := CBroadcastGetBuildClipStatusRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_broadcast_clip_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_clip_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastgetbuildclipstatusrequest() CBroadcastGetBuildClipStatusRequest { +return CBroadcastGetBuildClipStatusRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastgetbuildclipstatusrequest(o CBroadcastGetBuildClipStatusRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastgetbuildclipstatusrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastGetBuildClipStatusRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastgetbuildclipstatusrequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastGetBuildClipStatusResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CBroadcastGetBuildClipStatusResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cbroadcastgetbuildclipstatusresponse_unpack(buf []byte) ?CBroadcastGetBuildClipStatusResponse { +res := CBroadcastGetBuildClipStatusResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastgetbuildclipstatusresponse() CBroadcastGetBuildClipStatusResponse { +return CBroadcastGetBuildClipStatusResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastgetbuildclipstatusresponse(o CBroadcastGetBuildClipStatusResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastgetbuildclipstatusresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastGetBuildClipStatusResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastgetbuildclipstatusresponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastSetClipDetailsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +broadcast_clip_id u64 +has_broadcast_clip_id bool +start_time u32 +has_start_time bool +end_time u32 +has_end_time bool +video_description string +has_video_description bool +} +pub fn (o &CBroadcastSetClipDetailsRequest) pack() []byte { +mut res := []byte{} +if o.has_broadcast_clip_id { +res << vproto.pack_uint64_field(o.broadcast_clip_id, 1) +} + +if o.has_start_time { +res << vproto.pack_uint32_field(o.start_time, 2) +} + +if o.has_end_time { +res << vproto.pack_uint32_field(o.end_time, 3) +} + +if o.has_video_description { +res << vproto.pack_string_field(o.video_description, 4) +} + +return res +} + +pub fn cbroadcastsetclipdetailsrequest_unpack(buf []byte) ?CBroadcastSetClipDetailsRequest { +mut res := CBroadcastSetClipDetailsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_broadcast_clip_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_clip_id = v +i = ii +} + +2 { +res.has_start_time = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.start_time = v +i = ii +} + +3 { +res.has_end_time = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.end_time = v +i = ii +} + +4 { +res.has_video_description = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.video_description = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastsetclipdetailsrequest() CBroadcastSetClipDetailsRequest { +return CBroadcastSetClipDetailsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastsetclipdetailsrequest(o CBroadcastSetClipDetailsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastsetclipdetailsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastSetClipDetailsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastsetclipdetailsrequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastSetClipDetailsResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CBroadcastSetClipDetailsResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cbroadcastsetclipdetailsresponse_unpack(buf []byte) ?CBroadcastSetClipDetailsResponse { +res := CBroadcastSetClipDetailsResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastsetclipdetailsresponse() CBroadcastSetClipDetailsResponse { +return CBroadcastSetClipDetailsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastsetclipdetailsresponse(o CBroadcastSetClipDetailsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastsetclipdetailsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastSetClipDetailsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastsetclipdetailsresponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastGetClipDetailsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +broadcast_clip_id u64 +has_broadcast_clip_id bool +} +pub fn (o &CBroadcastGetClipDetailsRequest) pack() []byte { +mut res := []byte{} +if o.has_broadcast_clip_id { +res << vproto.pack_uint64_field(o.broadcast_clip_id, 1) +} + +return res +} + +pub fn cbroadcastgetclipdetailsrequest_unpack(buf []byte) ?CBroadcastGetClipDetailsRequest { +mut res := CBroadcastGetClipDetailsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_broadcast_clip_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_clip_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastgetclipdetailsrequest() CBroadcastGetClipDetailsRequest { +return CBroadcastGetClipDetailsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastgetclipdetailsrequest(o CBroadcastGetClipDetailsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastgetclipdetailsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastGetClipDetailsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastgetclipdetailsrequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastGetClipDetailsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +broadcast_clip_id u64 +has_broadcast_clip_id bool +video_id u64 +has_video_id bool +channel_id u64 +has_channel_id bool +app_id u32 +has_app_id bool +accountid_broadcaster u32 +has_accountid_broadcaster bool +accountid_clipmaker u32 +has_accountid_clipmaker bool +video_description string +has_video_description bool +start_time u32 +has_start_time bool +length_milliseconds u32 +has_length_milliseconds bool +thumbnail_path string +has_thumbnail_path bool +} +pub fn (o &CBroadcastGetClipDetailsResponse) pack() []byte { +mut res := []byte{} +if o.has_broadcast_clip_id { +res << vproto.pack_uint64_field(o.broadcast_clip_id, 1) +} + +if o.has_video_id { +res << vproto.pack_uint64_field(o.video_id, 2) +} + +if o.has_channel_id { +res << vproto.pack_uint64_field(o.channel_id, 3) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 4) +} + +if o.has_accountid_broadcaster { +res << vproto.pack_uint32_field(o.accountid_broadcaster, 5) +} + +if o.has_accountid_clipmaker { +res << vproto.pack_uint32_field(o.accountid_clipmaker, 6) +} + +if o.has_video_description { +res << vproto.pack_string_field(o.video_description, 7) +} + +if o.has_start_time { +res << vproto.pack_uint32_field(o.start_time, 8) +} + +if o.has_length_milliseconds { +res << vproto.pack_uint32_field(o.length_milliseconds, 9) +} + +if o.has_thumbnail_path { +res << vproto.pack_string_field(o.thumbnail_path, 10) +} + +return res +} + +pub fn cbroadcastgetclipdetailsresponse_unpack(buf []byte) ?CBroadcastGetClipDetailsResponse { +mut res := CBroadcastGetClipDetailsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_broadcast_clip_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_clip_id = v +i = ii +} + +2 { +res.has_video_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.video_id = v +i = ii +} + +3 { +res.has_channel_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.channel_id = v +i = ii +} + +4 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +5 { +res.has_accountid_broadcaster = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.accountid_broadcaster = v +i = ii +} + +6 { +res.has_accountid_clipmaker = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.accountid_clipmaker = v +i = ii +} + +7 { +res.has_video_description = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.video_description = v +i = ii +} + +8 { +res.has_start_time = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.start_time = v +i = ii +} + +9 { +res.has_length_milliseconds = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.length_milliseconds = v +i = ii +} + +10 { +res.has_thumbnail_path = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.thumbnail_path = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastgetclipdetailsresponse() CBroadcastGetClipDetailsResponse { +return CBroadcastGetClipDetailsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastgetclipdetailsresponse(o CBroadcastGetClipDetailsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastgetclipdetailsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastGetClipDetailsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastgetclipdetailsresponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastSetRTmpinfoRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +broadcast_permission int +has_broadcast_permission bool +update_token bool +has_update_token bool +broadcast_delay int +has_broadcast_delay bool +app_id u32 +has_app_id bool +required_app_id u32 +has_required_app_id bool +broadcast_chat_permission EBroadcastChatPermission +has_broadcast_chat_permission bool +broadcast_buffer int +has_broadcast_buffer bool +steamid u64 +has_steamid bool +chat_rate_limit u32 +has_chat_rate_limit bool +enable_replay bool +has_enable_replay bool +} +pub fn (o &CBroadcastSetRTmpinfoRequest) pack() []byte { +mut res := []byte{} +if o.has_broadcast_permission { +res << vproto.pack_int32_field(o.broadcast_permission, 1) +} + +if o.has_update_token { +res << vproto.pack_bool_field(o.update_token, 2) +} + +if o.has_broadcast_delay { +res << vproto.pack_int32_field(o.broadcast_delay, 3) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 4) +} + +if o.has_required_app_id { +res << vproto.pack_uint32_field(o.required_app_id, 5) +} + +if o.has_broadcast_chat_permission { +res << zzz_vproto_internal_pack_ebroadcastchatpermission(o.broadcast_chat_permission, 6) +} + +if o.has_broadcast_buffer { +res << vproto.pack_int32_field(o.broadcast_buffer, 7) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 8) +} + +if o.has_chat_rate_limit { +res << vproto.pack_uint32_field(o.chat_rate_limit, 9) +} + +if o.has_enable_replay { +res << vproto.pack_bool_field(o.enable_replay, 10) +} + +return res +} + +pub fn cbroadcastsetrtmpinforequest_unpack(buf []byte) ?CBroadcastSetRTmpinfoRequest { +mut res := CBroadcastSetRTmpinfoRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_broadcast_permission = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_permission = v +i = ii +} + +2 { +res.has_update_token = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.update_token = v +i = ii +} + +3 { +res.has_broadcast_delay = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_delay = v +i = ii +} + +4 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +5 { +res.has_required_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.required_app_id = v +i = ii +} + +6 { +res.has_broadcast_chat_permission = true +ii, v := zzz_vproto_internal_unpack_ebroadcastchatpermission(cur_buf, tag_wiretype.wire_type)? +res.broadcast_chat_permission = v +i = ii +} + +7 { +res.has_broadcast_buffer = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_buffer = v +i = ii +} + +8 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +9 { +res.has_chat_rate_limit = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.chat_rate_limit = v +i = ii +} + +10 { +res.has_enable_replay = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enable_replay = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastsetrtmpinforequest() CBroadcastSetRTmpinfoRequest { +return CBroadcastSetRTmpinfoRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastsetrtmpinforequest(o CBroadcastSetRTmpinfoRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastsetrtmpinforequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastSetRTmpinfoRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastsetrtmpinforequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastSetRTmpinfoResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CBroadcastSetRTmpinfoResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cbroadcastsetrtmpinforesponse_unpack(buf []byte) ?CBroadcastSetRTmpinfoResponse { +res := CBroadcastSetRTmpinfoResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastsetrtmpinforesponse() CBroadcastSetRTmpinfoResponse { +return CBroadcastSetRTmpinfoResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastsetrtmpinforesponse(o CBroadcastSetRTmpinfoResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastsetrtmpinforesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastSetRTmpinfoResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastsetrtmpinforesponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastGetRTmpinfoRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +ip u32 +has_ip bool +steamid u64 +has_steamid bool +} +pub fn (o &CBroadcastGetRTmpinfoRequest) pack() []byte { +mut res := []byte{} +if o.has_ip { +res << vproto.pack_uint32_field(o.ip, 1) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 2) +} + +return res +} + +pub fn cbroadcastgetrtmpinforequest_unpack(buf []byte) ?CBroadcastGetRTmpinfoRequest { +mut res := CBroadcastGetRTmpinfoRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_ip = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ip = v +i = ii +} + +2 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastgetrtmpinforequest() CBroadcastGetRTmpinfoRequest { +return CBroadcastGetRTmpinfoRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastgetrtmpinforequest(o CBroadcastGetRTmpinfoRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastgetrtmpinforequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastGetRTmpinfoRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastgetrtmpinforequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastGetRTmpinfoResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +broadcast_permission int +has_broadcast_permission bool +rtmp_host string +has_rtmp_host bool +rtmp_token string +has_rtmp_token bool +broadcast_delay int +has_broadcast_delay bool +app_id u32 +has_app_id bool +required_app_id u32 +has_required_app_id bool +broadcast_chat_permission EBroadcastChatPermission +has_broadcast_chat_permission bool +broadcast_buffer int +has_broadcast_buffer bool +steamid u64 +has_steamid bool +chat_rate_limit u32 +has_chat_rate_limit bool +enable_replay bool +has_enable_replay bool +} +pub fn (o &CBroadcastGetRTmpinfoResponse) pack() []byte { +mut res := []byte{} +if o.has_broadcast_permission { +res << vproto.pack_int32_field(o.broadcast_permission, 1) +} + +if o.has_rtmp_host { +res << vproto.pack_string_field(o.rtmp_host, 2) +} + +if o.has_rtmp_token { +res << vproto.pack_string_field(o.rtmp_token, 3) +} + +if o.has_broadcast_delay { +res << vproto.pack_int32_field(o.broadcast_delay, 4) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 5) +} + +if o.has_required_app_id { +res << vproto.pack_uint32_field(o.required_app_id, 6) +} + +if o.has_broadcast_chat_permission { +res << zzz_vproto_internal_pack_ebroadcastchatpermission(o.broadcast_chat_permission, 7) +} + +if o.has_broadcast_buffer { +res << vproto.pack_int32_field(o.broadcast_buffer, 8) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 9) +} + +if o.has_chat_rate_limit { +res << vproto.pack_uint32_field(o.chat_rate_limit, 10) +} + +if o.has_enable_replay { +res << vproto.pack_bool_field(o.enable_replay, 11) +} + +return res +} + +pub fn cbroadcastgetrtmpinforesponse_unpack(buf []byte) ?CBroadcastGetRTmpinfoResponse { +mut res := CBroadcastGetRTmpinfoResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_broadcast_permission = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_permission = v +i = ii +} + +2 { +res.has_rtmp_host = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.rtmp_host = v +i = ii +} + +3 { +res.has_rtmp_token = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.rtmp_token = v +i = ii +} + +4 { +res.has_broadcast_delay = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_delay = v +i = ii +} + +5 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +6 { +res.has_required_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.required_app_id = v +i = ii +} + +7 { +res.has_broadcast_chat_permission = true +ii, v := zzz_vproto_internal_unpack_ebroadcastchatpermission(cur_buf, tag_wiretype.wire_type)? +res.broadcast_chat_permission = v +i = ii +} + +8 { +res.has_broadcast_buffer = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_buffer = v +i = ii +} + +9 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +10 { +res.has_chat_rate_limit = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.chat_rate_limit = v +i = ii +} + +11 { +res.has_enable_replay = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enable_replay = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastgetrtmpinforesponse() CBroadcastGetRTmpinfoResponse { +return CBroadcastGetRTmpinfoResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastgetrtmpinforesponse(o CBroadcastGetRTmpinfoResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastgetrtmpinforesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastGetRTmpinfoResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastgetrtmpinforesponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastWebRTchaveTUrnserverNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +broadcast_session_id u64 +has_broadcast_session_id bool +turn_server string +has_turn_server bool +} +pub fn (o &CBroadcastWebRTchaveTUrnserverNotification) pack() []byte { +mut res := []byte{} +if o.has_broadcast_session_id { +res << vproto.pack_64bit_field(o.broadcast_session_id, 1) +} + +if o.has_turn_server { +res << vproto.pack_string_field(o.turn_server, 2) +} + +return res +} + +pub fn cbroadcastwebrtchaveturnservernotification_unpack(buf []byte) ?CBroadcastWebRTchaveTUrnserverNotification { +mut res := CBroadcastWebRTchaveTUrnserverNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_broadcast_session_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_session_id = v +i = ii +} + +2 { +res.has_turn_server = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.turn_server = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastwebrtchaveturnservernotification() CBroadcastWebRTchaveTUrnserverNotification { +return CBroadcastWebRTchaveTUrnserverNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastwebrtchaveturnservernotification(o CBroadcastWebRTchaveTUrnserverNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastwebrtchaveturnservernotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastWebRTchaveTUrnserverNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastwebrtchaveturnservernotification_unpack(v)? +return i, unpacked +} +pub struct CBroadcastWebRTcstartResultRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +webrtc_session_id u64 +has_webrtc_session_id bool +started bool +has_started bool +offer string +has_offer bool +resolution_x u32 +has_resolution_x bool +resolution_y u32 +has_resolution_y bool +fps u32 +has_fps bool +} +pub fn (o &CBroadcastWebRTcstartResultRequest) pack() []byte { +mut res := []byte{} +if o.has_webrtc_session_id { +res << vproto.pack_64bit_field(o.webrtc_session_id, 1) +} + +if o.has_started { +res << vproto.pack_bool_field(o.started, 2) +} + +if o.has_offer { +res << vproto.pack_string_field(o.offer, 3) +} + +if o.has_resolution_x { +res << vproto.pack_uint32_field(o.resolution_x, 4) +} + +if o.has_resolution_y { +res << vproto.pack_uint32_field(o.resolution_y, 5) +} + +if o.has_fps { +res << vproto.pack_uint32_field(o.fps, 6) +} + +return res +} + +pub fn cbroadcastwebrtcstartresultrequest_unpack(buf []byte) ?CBroadcastWebRTcstartResultRequest { +mut res := CBroadcastWebRTcstartResultRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_webrtc_session_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.webrtc_session_id = v +i = ii +} + +2 { +res.has_started = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.started = v +i = ii +} + +3 { +res.has_offer = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.offer = v +i = ii +} + +4 { +res.has_resolution_x = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.resolution_x = v +i = ii +} + +5 { +res.has_resolution_y = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.resolution_y = v +i = ii +} + +6 { +res.has_fps = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.fps = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastwebrtcstartresultrequest() CBroadcastWebRTcstartResultRequest { +return CBroadcastWebRTcstartResultRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastwebrtcstartresultrequest(o CBroadcastWebRTcstartResultRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastwebrtcstartresultrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastWebRTcstartResultRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastwebrtcstartresultrequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastWebRTcstartResultResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CBroadcastWebRTcstartResultResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cbroadcastwebrtcstartresultresponse_unpack(buf []byte) ?CBroadcastWebRTcstartResultResponse { +res := CBroadcastWebRTcstartResultResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastwebrtcstartresultresponse() CBroadcastWebRTcstartResultResponse { +return CBroadcastWebRTcstartResultResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastwebrtcstartresultresponse(o CBroadcastWebRTcstartResultResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastwebrtcstartresultresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastWebRTcstartResultResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastwebrtcstartresultresponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastWebRTcstoppedRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +webrtc_session_id u64 +has_webrtc_session_id bool +} +pub fn (o &CBroadcastWebRTcstoppedRequest) pack() []byte { +mut res := []byte{} +if o.has_webrtc_session_id { +res << vproto.pack_64bit_field(o.webrtc_session_id, 1) +} + +return res +} + +pub fn cbroadcastwebrtcstoppedrequest_unpack(buf []byte) ?CBroadcastWebRTcstoppedRequest { +mut res := CBroadcastWebRTcstoppedRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_webrtc_session_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.webrtc_session_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastwebrtcstoppedrequest() CBroadcastWebRTcstoppedRequest { +return CBroadcastWebRTcstoppedRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastwebrtcstoppedrequest(o CBroadcastWebRTcstoppedRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastwebrtcstoppedrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastWebRTcstoppedRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastwebrtcstoppedrequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastWebRTcstoppedResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CBroadcastWebRTcstoppedResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cbroadcastwebrtcstoppedresponse_unpack(buf []byte) ?CBroadcastWebRTcstoppedResponse { +res := CBroadcastWebRTcstoppedResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastwebrtcstoppedresponse() CBroadcastWebRTcstoppedResponse { +return CBroadcastWebRTcstoppedResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastwebrtcstoppedresponse(o CBroadcastWebRTcstoppedResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastwebrtcstoppedresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastWebRTcstoppedResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastwebrtcstoppedresponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastWebRTcsetAnswerRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +broadcaster_steamid u64 +has_broadcaster_steamid bool +webrtc_session_id u64 +has_webrtc_session_id bool +answer string +has_answer bool +} +pub fn (o &CBroadcastWebRTcsetAnswerRequest) pack() []byte { +mut res := []byte{} +if o.has_broadcaster_steamid { +res << vproto.pack_64bit_field(o.broadcaster_steamid, 1) +} + +if o.has_webrtc_session_id { +res << vproto.pack_64bit_field(o.webrtc_session_id, 2) +} + +if o.has_answer { +res << vproto.pack_string_field(o.answer, 3) +} + +return res +} + +pub fn cbroadcastwebrtcsetanswerrequest_unpack(buf []byte) ?CBroadcastWebRTcsetAnswerRequest { +mut res := CBroadcastWebRTcsetAnswerRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_broadcaster_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcaster_steamid = v +i = ii +} + +2 { +res.has_webrtc_session_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.webrtc_session_id = v +i = ii +} + +3 { +res.has_answer = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.answer = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastwebrtcsetanswerrequest() CBroadcastWebRTcsetAnswerRequest { +return CBroadcastWebRTcsetAnswerRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastwebrtcsetanswerrequest(o CBroadcastWebRTcsetAnswerRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastwebrtcsetanswerrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastWebRTcsetAnswerRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastwebrtcsetanswerrequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastWebRTcsetAnswerResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CBroadcastWebRTcsetAnswerResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cbroadcastwebrtcsetanswerresponse_unpack(buf []byte) ?CBroadcastWebRTcsetAnswerResponse { +res := CBroadcastWebRTcsetAnswerResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastwebrtcsetanswerresponse() CBroadcastWebRTcsetAnswerResponse { +return CBroadcastWebRTcsetAnswerResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastwebrtcsetanswerresponse(o CBroadcastWebRTcsetAnswerResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastwebrtcsetanswerresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastWebRTcsetAnswerResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastwebrtcsetanswerresponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastWebRTclookupTUrnserverRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +cellid u32 +has_cellid bool +} +pub fn (o &CBroadcastWebRTclookupTUrnserverRequest) pack() []byte { +mut res := []byte{} +if o.has_cellid { +res << vproto.pack_uint32_field(o.cellid, 1) +} + +return res +} + +pub fn cbroadcastwebrtclookupturnserverrequest_unpack(buf []byte) ?CBroadcastWebRTclookupTUrnserverRequest { +mut res := CBroadcastWebRTclookupTUrnserverRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_cellid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cellid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastwebrtclookupturnserverrequest() CBroadcastWebRTclookupTUrnserverRequest { +return CBroadcastWebRTclookupTUrnserverRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastwebrtclookupturnserverrequest(o CBroadcastWebRTclookupTUrnserverRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastwebrtclookupturnserverrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastWebRTclookupTUrnserverRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastwebrtclookupturnserverrequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastWebRTclookupTUrnserverResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +turn_server string +has_turn_server bool +} +pub fn (o &CBroadcastWebRTclookupTUrnserverResponse) pack() []byte { +mut res := []byte{} +if o.has_turn_server { +res << vproto.pack_string_field(o.turn_server, 1) +} + +return res +} + +pub fn cbroadcastwebrtclookupturnserverresponse_unpack(buf []byte) ?CBroadcastWebRTclookupTUrnserverResponse { +mut res := CBroadcastWebRTclookupTUrnserverResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_turn_server = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.turn_server = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastwebrtclookupturnserverresponse() CBroadcastWebRTclookupTUrnserverResponse { +return CBroadcastWebRTclookupTUrnserverResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastwebrtclookupturnserverresponse(o CBroadcastWebRTclookupTUrnserverResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastwebrtclookupturnserverresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastWebRTclookupTUrnserverResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastwebrtclookupturnserverresponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastWebRTccandidate { +mut: +unknown_fields []vproto.UnknownField +pub mut: +sdp_mid string +has_sdp_mid bool +sdp_mline_index int +has_sdp_mline_index bool +candidate string +has_candidate bool +} +pub fn (o &CBroadcastWebRTccandidate) pack() []byte { +mut res := []byte{} +if o.has_sdp_mid { +res << vproto.pack_string_field(o.sdp_mid, 1) +} + +if o.has_sdp_mline_index { +res << vproto.pack_int32_field(o.sdp_mline_index, 2) +} + +if o.has_candidate { +res << vproto.pack_string_field(o.candidate, 3) +} + +return res +} + +pub fn cbroadcastwebrtccandidate_unpack(buf []byte) ?CBroadcastWebRTccandidate { +mut res := CBroadcastWebRTccandidate{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_sdp_mid = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.sdp_mid = v +i = ii +} + +2 { +res.has_sdp_mline_index = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.sdp_mline_index = v +i = ii +} + +3 { +res.has_candidate = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.candidate = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastwebrtccandidate() CBroadcastWebRTccandidate { +return CBroadcastWebRTccandidate{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastwebrtccandidate(o CBroadcastWebRTccandidate, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastwebrtccandidate(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastWebRTccandidate) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastwebrtccandidate_unpack(v)? +return i, unpacked +} +pub struct CBroadcastWebRTcaddHostCandidateRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +webrtc_session_id u64 +has_webrtc_session_id bool +candidate CBroadcastWebRTccandidate +has_candidate bool +} +pub fn (o &CBroadcastWebRTcaddHostCandidateRequest) pack() []byte { +mut res := []byte{} +if o.has_webrtc_session_id { +res << vproto.pack_64bit_field(o.webrtc_session_id, 1) +} + +if o.has_candidate { +res << zzz_vproto_internal_pack_cbroadcastwebrtccandidate(o.candidate, 2) +} + +return res +} + +pub fn cbroadcastwebrtcaddhostcandidaterequest_unpack(buf []byte) ?CBroadcastWebRTcaddHostCandidateRequest { +mut res := CBroadcastWebRTcaddHostCandidateRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_webrtc_session_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.webrtc_session_id = v +i = ii +} + +2 { +res.has_candidate = true +ii, v := zzz_vproto_internal_unpack_cbroadcastwebrtccandidate(cur_buf, tag_wiretype.wire_type)? +res.candidate = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastwebrtcaddhostcandidaterequest() CBroadcastWebRTcaddHostCandidateRequest { +return CBroadcastWebRTcaddHostCandidateRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastwebrtcaddhostcandidaterequest(o CBroadcastWebRTcaddHostCandidateRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastwebrtcaddhostcandidaterequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastWebRTcaddHostCandidateRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastwebrtcaddhostcandidaterequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastWebRTcaddHostCandidateResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CBroadcastWebRTcaddHostCandidateResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cbroadcastwebrtcaddhostcandidateresponse_unpack(buf []byte) ?CBroadcastWebRTcaddHostCandidateResponse { +res := CBroadcastWebRTcaddHostCandidateResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastwebrtcaddhostcandidateresponse() CBroadcastWebRTcaddHostCandidateResponse { +return CBroadcastWebRTcaddHostCandidateResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastwebrtcaddhostcandidateresponse(o CBroadcastWebRTcaddHostCandidateResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastwebrtcaddhostcandidateresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastWebRTcaddHostCandidateResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastwebrtcaddhostcandidateresponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastWebRTcaddViewerCandidateRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +broadcaster_steamid u64 +has_broadcaster_steamid bool +webrtc_session_id u64 +has_webrtc_session_id bool +candidate CBroadcastWebRTccandidate +has_candidate bool +} +pub fn (o &CBroadcastWebRTcaddViewerCandidateRequest) pack() []byte { +mut res := []byte{} +if o.has_broadcaster_steamid { +res << vproto.pack_64bit_field(o.broadcaster_steamid, 1) +} + +if o.has_webrtc_session_id { +res << vproto.pack_64bit_field(o.webrtc_session_id, 2) +} + +if o.has_candidate { +res << zzz_vproto_internal_pack_cbroadcastwebrtccandidate(o.candidate, 3) +} + +return res +} + +pub fn cbroadcastwebrtcaddviewercandidaterequest_unpack(buf []byte) ?CBroadcastWebRTcaddViewerCandidateRequest { +mut res := CBroadcastWebRTcaddViewerCandidateRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_broadcaster_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcaster_steamid = v +i = ii +} + +2 { +res.has_webrtc_session_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.webrtc_session_id = v +i = ii +} + +3 { +res.has_candidate = true +ii, v := zzz_vproto_internal_unpack_cbroadcastwebrtccandidate(cur_buf, tag_wiretype.wire_type)? +res.candidate = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastwebrtcaddviewercandidaterequest() CBroadcastWebRTcaddViewerCandidateRequest { +return CBroadcastWebRTcaddViewerCandidateRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastwebrtcaddviewercandidaterequest(o CBroadcastWebRTcaddViewerCandidateRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastwebrtcaddviewercandidaterequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastWebRTcaddViewerCandidateRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastwebrtcaddviewercandidaterequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastWebRTcaddViewerCandidateResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CBroadcastWebRTcaddViewerCandidateResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cbroadcastwebrtcaddviewercandidateresponse_unpack(buf []byte) ?CBroadcastWebRTcaddViewerCandidateResponse { +res := CBroadcastWebRTcaddViewerCandidateResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastwebrtcaddviewercandidateresponse() CBroadcastWebRTcaddViewerCandidateResponse { +return CBroadcastWebRTcaddViewerCandidateResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastwebrtcaddviewercandidateresponse(o CBroadcastWebRTcaddViewerCandidateResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastwebrtcaddviewercandidateresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastWebRTcaddViewerCandidateResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastwebrtcaddviewercandidateresponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastWebRTcgetHostCandidatesRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +broadcaster_steamid u64 +has_broadcaster_steamid bool +webrtc_session_id u64 +has_webrtc_session_id bool +candidate_generation u32 +has_candidate_generation bool +} +pub fn (o &CBroadcastWebRTcgetHostCandidatesRequest) pack() []byte { +mut res := []byte{} +if o.has_broadcaster_steamid { +res << vproto.pack_64bit_field(o.broadcaster_steamid, 1) +} + +if o.has_webrtc_session_id { +res << vproto.pack_64bit_field(o.webrtc_session_id, 2) +} + +if o.has_candidate_generation { +res << vproto.pack_uint32_field(o.candidate_generation, 3) +} + +return res +} + +pub fn cbroadcastwebrtcgethostcandidatesrequest_unpack(buf []byte) ?CBroadcastWebRTcgetHostCandidatesRequest { +mut res := CBroadcastWebRTcgetHostCandidatesRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_broadcaster_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcaster_steamid = v +i = ii +} + +2 { +res.has_webrtc_session_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.webrtc_session_id = v +i = ii +} + +3 { +res.has_candidate_generation = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.candidate_generation = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastwebrtcgethostcandidatesrequest() CBroadcastWebRTcgetHostCandidatesRequest { +return CBroadcastWebRTcgetHostCandidatesRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastwebrtcgethostcandidatesrequest(o CBroadcastWebRTcgetHostCandidatesRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastwebrtcgethostcandidatesrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastWebRTcgetHostCandidatesRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastwebrtcgethostcandidatesrequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastWebRTcgetHostCandidatesResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +candidate_generation u32 +has_candidate_generation bool +candidates []CBroadcastWebRTccandidate +} +pub fn (o &CBroadcastWebRTcgetHostCandidatesResponse) pack() []byte { +mut res := []byte{} +if o.has_candidate_generation { +res << vproto.pack_uint32_field(o.candidate_generation, 1) +} + +// [packed=false] +for _, x in o.candidates { +res << zzz_vproto_internal_pack_cbroadcastwebrtccandidate(x, 2) +} + +return res +} + +pub fn cbroadcastwebrtcgethostcandidatesresponse_unpack(buf []byte) ?CBroadcastWebRTcgetHostCandidatesResponse { +mut res := CBroadcastWebRTcgetHostCandidatesResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_candidate_generation = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.candidate_generation = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cbroadcastwebrtccandidate(cur_buf, tag_wiretype.wire_type)? +res.candidates << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastwebrtcgethostcandidatesresponse() CBroadcastWebRTcgetHostCandidatesResponse { +return CBroadcastWebRTcgetHostCandidatesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastwebrtcgethostcandidatesresponse(o CBroadcastWebRTcgetHostCandidatesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastwebrtcgethostcandidatesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastWebRTcgetHostCandidatesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastwebrtcgethostcandidatesresponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastGetBroadcastUploadStatsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +row_limit u32 +has_row_limit bool +start_time u32 +has_start_time bool +upload_id u64 +has_upload_id bool +steamid u64 +has_steamid bool +session_id u64 +has_session_id bool +} +pub fn (o &CBroadcastGetBroadcastUploadStatsRequest) pack() []byte { +mut res := []byte{} +if o.has_row_limit { +res << vproto.pack_uint32_field(o.row_limit, 1) +} + +if o.has_start_time { +res << vproto.pack_uint32_field(o.start_time, 2) +} + +if o.has_upload_id { +res << vproto.pack_uint64_field(o.upload_id, 3) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 4) +} + +if o.has_session_id { +res << vproto.pack_uint64_field(o.session_id, 5) +} + +return res +} + +pub fn cbroadcastgetbroadcastuploadstatsrequest_unpack(buf []byte) ?CBroadcastGetBroadcastUploadStatsRequest { +mut res := CBroadcastGetBroadcastUploadStatsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_row_limit = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.row_limit = v +i = ii +} + +2 { +res.has_start_time = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.start_time = v +i = ii +} + +3 { +res.has_upload_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.upload_id = v +i = ii +} + +4 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +5 { +res.has_session_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.session_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastgetbroadcastuploadstatsrequest() CBroadcastGetBroadcastUploadStatsRequest { +return CBroadcastGetBroadcastUploadStatsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastgetbroadcastuploadstatsrequest(o CBroadcastGetBroadcastUploadStatsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastgetbroadcastuploadstatsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastGetBroadcastUploadStatsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastgetbroadcastuploadstatsrequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastGetBroadcastUploadStatsResponseUploadStats { +mut: +unknown_fields []vproto.UnknownField +pub mut: +upload_result u32 +has_upload_result bool +time_stopped u32 +has_time_stopped bool +seconds_uploaded u32 +has_seconds_uploaded bool +max_viewers u32 +has_max_viewers bool +resolution_x u32 +has_resolution_x bool +resolution_y u32 +has_resolution_y bool +avg_bandwidth u32 +has_avg_bandwidth bool +total_bytes u64 +has_total_bytes bool +app_id u32 +has_app_id bool +total_unique_viewers u32 +has_total_unique_viewers bool +total_seconds_watched u64 +has_total_seconds_watched bool +time_started u32 +has_time_started bool +upload_id u64 +has_upload_id bool +local_address string +has_local_address bool +remote_address string +has_remote_address bool +frames_per_second u32 +has_frames_per_second bool +num_representations u32 +has_num_representations bool +app_name string +has_app_name bool +is_replay bool +has_is_replay bool +session_id u64 +has_session_id bool +} +pub fn (o &CBroadcastGetBroadcastUploadStatsResponseUploadStats) pack() []byte { +mut res := []byte{} +if o.has_upload_result { +res << vproto.pack_uint32_field(o.upload_result, 1) +} + +if o.has_time_stopped { +res << vproto.pack_uint32_field(o.time_stopped, 2) +} + +if o.has_seconds_uploaded { +res << vproto.pack_uint32_field(o.seconds_uploaded, 3) +} + +if o.has_max_viewers { +res << vproto.pack_uint32_field(o.max_viewers, 4) +} + +if o.has_resolution_x { +res << vproto.pack_uint32_field(o.resolution_x, 5) +} + +if o.has_resolution_y { +res << vproto.pack_uint32_field(o.resolution_y, 6) +} + +if o.has_avg_bandwidth { +res << vproto.pack_uint32_field(o.avg_bandwidth, 7) +} + +if o.has_total_bytes { +res << vproto.pack_uint64_field(o.total_bytes, 8) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 9) +} + +if o.has_total_unique_viewers { +res << vproto.pack_uint32_field(o.total_unique_viewers, 10) +} + +if o.has_total_seconds_watched { +res << vproto.pack_uint64_field(o.total_seconds_watched, 11) +} + +if o.has_time_started { +res << vproto.pack_uint32_field(o.time_started, 12) +} + +if o.has_upload_id { +res << vproto.pack_uint64_field(o.upload_id, 13) +} + +if o.has_local_address { +res << vproto.pack_string_field(o.local_address, 14) +} + +if o.has_remote_address { +res << vproto.pack_string_field(o.remote_address, 15) +} + +if o.has_frames_per_second { +res << vproto.pack_uint32_field(o.frames_per_second, 16) +} + +if o.has_num_representations { +res << vproto.pack_uint32_field(o.num_representations, 17) +} + +if o.has_app_name { +res << vproto.pack_string_field(o.app_name, 18) +} + +if o.has_is_replay { +res << vproto.pack_bool_field(o.is_replay, 19) +} + +if o.has_session_id { +res << vproto.pack_uint64_field(o.session_id, 20) +} + +return res +} + +pub fn cbroadcastgetbroadcastuploadstatsresponseuploadstats_unpack(buf []byte) ?CBroadcastGetBroadcastUploadStatsResponseUploadStats { +mut res := CBroadcastGetBroadcastUploadStatsResponseUploadStats{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_upload_result = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.upload_result = v +i = ii +} + +2 { +res.has_time_stopped = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_stopped = v +i = ii +} + +3 { +res.has_seconds_uploaded = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_uploaded = v +i = ii +} + +4 { +res.has_max_viewers = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.max_viewers = v +i = ii +} + +5 { +res.has_resolution_x = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.resolution_x = v +i = ii +} + +6 { +res.has_resolution_y = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.resolution_y = v +i = ii +} + +7 { +res.has_avg_bandwidth = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.avg_bandwidth = v +i = ii +} + +8 { +res.has_total_bytes = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.total_bytes = v +i = ii +} + +9 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +10 { +res.has_total_unique_viewers = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.total_unique_viewers = v +i = ii +} + +11 { +res.has_total_seconds_watched = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.total_seconds_watched = v +i = ii +} + +12 { +res.has_time_started = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_started = v +i = ii +} + +13 { +res.has_upload_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.upload_id = v +i = ii +} + +14 { +res.has_local_address = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.local_address = v +i = ii +} + +15 { +res.has_remote_address = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.remote_address = v +i = ii +} + +16 { +res.has_frames_per_second = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.frames_per_second = v +i = ii +} + +17 { +res.has_num_representations = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.num_representations = v +i = ii +} + +18 { +res.has_app_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.app_name = v +i = ii +} + +19 { +res.has_is_replay = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_replay = v +i = ii +} + +20 { +res.has_session_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.session_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastgetbroadcastuploadstatsresponseuploadstats() CBroadcastGetBroadcastUploadStatsResponseUploadStats { +return CBroadcastGetBroadcastUploadStatsResponseUploadStats{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastgetbroadcastuploadstatsresponseuploadstats(o CBroadcastGetBroadcastUploadStatsResponseUploadStats, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastgetbroadcastuploadstatsresponseuploadstats(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastGetBroadcastUploadStatsResponseUploadStats) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastgetbroadcastuploadstatsresponseuploadstats_unpack(v)? +return i, unpacked +} +pub struct CBroadcastGetBroadcastUploadStatsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +upload_stats []CBroadcastGetBroadcastUploadStatsResponseUploadStats +} +pub fn (o &CBroadcastGetBroadcastUploadStatsResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.upload_stats { +res << zzz_vproto_internal_pack_cbroadcastgetbroadcastuploadstatsresponseuploadstats(x, 1) +} + +return res +} + +pub fn cbroadcastgetbroadcastuploadstatsresponse_unpack(buf []byte) ?CBroadcastGetBroadcastUploadStatsResponse { +mut res := CBroadcastGetBroadcastUploadStatsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cbroadcastgetbroadcastuploadstatsresponseuploadstats(cur_buf, tag_wiretype.wire_type)? +res.upload_stats << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastgetbroadcastuploadstatsresponse() CBroadcastGetBroadcastUploadStatsResponse { +return CBroadcastGetBroadcastUploadStatsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastgetbroadcastuploadstatsresponse(o CBroadcastGetBroadcastUploadStatsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastgetbroadcastuploadstatsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastGetBroadcastUploadStatsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastgetbroadcastuploadstatsresponse_unpack(v)? +return i, unpacked +} +pub struct CBroadcastGetBroadcastViewerStatsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +upload_id u64 +has_upload_id bool +steamid u64 +has_steamid bool +} +pub fn (o &CBroadcastGetBroadcastViewerStatsRequest) pack() []byte { +mut res := []byte{} +if o.has_upload_id { +res << vproto.pack_uint64_field(o.upload_id, 1) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 2) +} + +return res +} + +pub fn cbroadcastgetbroadcastviewerstatsrequest_unpack(buf []byte) ?CBroadcastGetBroadcastViewerStatsRequest { +mut res := CBroadcastGetBroadcastViewerStatsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_upload_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.upload_id = v +i = ii +} + +2 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastgetbroadcastviewerstatsrequest() CBroadcastGetBroadcastViewerStatsRequest { +return CBroadcastGetBroadcastViewerStatsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastgetbroadcastviewerstatsrequest(o CBroadcastGetBroadcastViewerStatsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastgetbroadcastviewerstatsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastGetBroadcastViewerStatsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastgetbroadcastviewerstatsrequest_unpack(v)? +return i, unpacked +} +pub struct CBroadcastGetBroadcastViewerStatsResponseViewerStats { +mut: +unknown_fields []vproto.UnknownField +pub mut: +time u32 +has_time bool +num_viewers u32 +has_num_viewers bool +} +pub fn (o &CBroadcastGetBroadcastViewerStatsResponseViewerStats) pack() []byte { +mut res := []byte{} +if o.has_time { +res << vproto.pack_uint32_field(o.time, 1) +} + +if o.has_num_viewers { +res << vproto.pack_uint32_field(o.num_viewers, 2) +} + +return res +} + +pub fn cbroadcastgetbroadcastviewerstatsresponseviewerstats_unpack(buf []byte) ?CBroadcastGetBroadcastViewerStatsResponseViewerStats { +mut res := CBroadcastGetBroadcastViewerStatsResponseViewerStats{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_time = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time = v +i = ii +} + +2 { +res.has_num_viewers = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.num_viewers = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastgetbroadcastviewerstatsresponseviewerstats() CBroadcastGetBroadcastViewerStatsResponseViewerStats { +return CBroadcastGetBroadcastViewerStatsResponseViewerStats{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastgetbroadcastviewerstatsresponseviewerstats(o CBroadcastGetBroadcastViewerStatsResponseViewerStats, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastgetbroadcastviewerstatsresponseviewerstats(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastGetBroadcastViewerStatsResponseViewerStats) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastgetbroadcastviewerstatsresponseviewerstats_unpack(v)? +return i, unpacked +} +pub struct CBroadcastGetBroadcastViewerStatsResponseCountryStats { +mut: +unknown_fields []vproto.UnknownField +pub mut: +country_code string +has_country_code bool +num_viewers u32 +has_num_viewers bool +} +pub fn (o &CBroadcastGetBroadcastViewerStatsResponseCountryStats) pack() []byte { +mut res := []byte{} +if o.has_country_code { +res << vproto.pack_string_field(o.country_code, 1) +} + +if o.has_num_viewers { +res << vproto.pack_uint32_field(o.num_viewers, 2) +} + +return res +} + +pub fn cbroadcastgetbroadcastviewerstatsresponsecountrystats_unpack(buf []byte) ?CBroadcastGetBroadcastViewerStatsResponseCountryStats { +mut res := CBroadcastGetBroadcastViewerStatsResponseCountryStats{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_country_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.country_code = v +i = ii +} + +2 { +res.has_num_viewers = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.num_viewers = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastgetbroadcastviewerstatsresponsecountrystats() CBroadcastGetBroadcastViewerStatsResponseCountryStats { +return CBroadcastGetBroadcastViewerStatsResponseCountryStats{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastgetbroadcastviewerstatsresponsecountrystats(o CBroadcastGetBroadcastViewerStatsResponseCountryStats, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastgetbroadcastviewerstatsresponsecountrystats(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastGetBroadcastViewerStatsResponseCountryStats) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastgetbroadcastviewerstatsresponsecountrystats_unpack(v)? +return i, unpacked +} +pub struct CBroadcastGetBroadcastViewerStatsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +viewer_stats []CBroadcastGetBroadcastViewerStatsResponseViewerStats +country_stats []CBroadcastGetBroadcastViewerStatsResponseCountryStats +} +pub fn (o &CBroadcastGetBroadcastViewerStatsResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.viewer_stats { +res << zzz_vproto_internal_pack_cbroadcastgetbroadcastviewerstatsresponseviewerstats(x, 1) +} + +// [packed=false] +for _, x in o.country_stats { +res << zzz_vproto_internal_pack_cbroadcastgetbroadcastviewerstatsresponsecountrystats(x, 2) +} + +return res +} + +pub fn cbroadcastgetbroadcastviewerstatsresponse_unpack(buf []byte) ?CBroadcastGetBroadcastViewerStatsResponse { +mut res := CBroadcastGetBroadcastViewerStatsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cbroadcastgetbroadcastviewerstatsresponseviewerstats(cur_buf, tag_wiretype.wire_type)? +res.viewer_stats << v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cbroadcastgetbroadcastviewerstatsresponsecountrystats(cur_buf, tag_wiretype.wire_type)? +res.country_stats << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastgetbroadcastviewerstatsresponse() CBroadcastGetBroadcastViewerStatsResponse { +return CBroadcastGetBroadcastViewerStatsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastgetbroadcastviewerstatsresponse(o CBroadcastGetBroadcastViewerStatsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastgetbroadcastviewerstatsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastGetBroadcastViewerStatsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastgetbroadcastviewerstatsresponse_unpack(v)? +return i, unpacked +} +[_allow_multiple_values] +enum CBroadcastBroadcastViewerStateNotificationEViewerState { +k_eviewerneedsapproval = 1 +k_eviewerwatching = 2 +k_eviewerleft = 3 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_cbroadcastbroadcastviewerstatenotificationeviewerstate(e CBroadcastBroadcastViewerStateNotificationEViewerState, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_cbroadcastbroadcastviewerstatenotificationeviewerstate(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastBroadcastViewerStateNotificationEViewerState) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, CBroadcastBroadcastViewerStateNotificationEViewerState(v) +} +pub struct CBroadcastBroadcastViewerStateNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +state CBroadcastBroadcastViewerStateNotificationEViewerState +has_state bool +} +pub fn (o &CBroadcastBroadcastViewerStateNotification) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_state { +res << zzz_vproto_internal_pack_cbroadcastbroadcastviewerstatenotificationeviewerstate(o.state, 2) +} + +return res +} + +pub fn cbroadcastbroadcastviewerstatenotification_unpack(buf []byte) ?CBroadcastBroadcastViewerStateNotification { +mut res := CBroadcastBroadcastViewerStateNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_state = true +ii, v := zzz_vproto_internal_unpack_cbroadcastbroadcastviewerstatenotificationeviewerstate(cur_buf, tag_wiretype.wire_type)? +res.state = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastbroadcastviewerstatenotification() CBroadcastBroadcastViewerStateNotification { +return CBroadcastBroadcastViewerStateNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastbroadcastviewerstatenotification(o CBroadcastBroadcastViewerStateNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastbroadcastviewerstatenotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastBroadcastViewerStateNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastbroadcastviewerstatenotification_unpack(v)? +return i, unpacked +} +pub struct CBroadcastWaitingBroadcastViewerNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +broadcast_id u64 +has_broadcast_id bool +} +pub fn (o &CBroadcastWaitingBroadcastViewerNotification) pack() []byte { +mut res := []byte{} +if o.has_broadcast_id { +res << vproto.pack_64bit_field(o.broadcast_id, 1) +} + +return res +} + +pub fn cbroadcastwaitingbroadcastviewernotification_unpack(buf []byte) ?CBroadcastWaitingBroadcastViewerNotification { +mut res := CBroadcastWaitingBroadcastViewerNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_broadcast_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastwaitingbroadcastviewernotification() CBroadcastWaitingBroadcastViewerNotification { +return CBroadcastWaitingBroadcastViewerNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastwaitingbroadcastviewernotification(o CBroadcastWaitingBroadcastViewerNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastwaitingbroadcastviewernotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastWaitingBroadcastViewerNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastwaitingbroadcastviewernotification_unpack(v)? +return i, unpacked +} +pub struct CBroadcastBroadcastUploadStartedNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +broadcast_id u64 +has_broadcast_id bool +upload_token string +has_upload_token bool +upload_address string +has_upload_address bool +http_address string +has_http_address bool +broadcast_upload_id u64 +has_broadcast_upload_id bool +heartbeat_interval_seconds u32 +has_heartbeat_interval_seconds bool +is_rtmp bool +has_is_rtmp bool +} +pub fn (o &CBroadcastBroadcastUploadStartedNotification) pack() []byte { +mut res := []byte{} +if o.has_broadcast_id { +res << vproto.pack_64bit_field(o.broadcast_id, 1) +} + +if o.has_upload_token { +res << vproto.pack_string_field(o.upload_token, 2) +} + +if o.has_upload_address { +res << vproto.pack_string_field(o.upload_address, 3) +} + +if o.has_http_address { +res << vproto.pack_string_field(o.http_address, 4) +} + +if o.has_broadcast_upload_id { +res << vproto.pack_64bit_field(o.broadcast_upload_id, 5) +} + +if o.has_heartbeat_interval_seconds { +res << vproto.pack_uint32_field(o.heartbeat_interval_seconds, 6) +} + +if o.has_is_rtmp { +res << vproto.pack_bool_field(o.is_rtmp, 7) +} + +return res +} + +pub fn cbroadcastbroadcastuploadstartednotification_unpack(buf []byte) ?CBroadcastBroadcastUploadStartedNotification { +mut res := CBroadcastBroadcastUploadStartedNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_broadcast_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_id = v +i = ii +} + +2 { +res.has_upload_token = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.upload_token = v +i = ii +} + +3 { +res.has_upload_address = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.upload_address = v +i = ii +} + +4 { +res.has_http_address = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.http_address = v +i = ii +} + +5 { +res.has_broadcast_upload_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_upload_id = v +i = ii +} + +6 { +res.has_heartbeat_interval_seconds = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.heartbeat_interval_seconds = v +i = ii +} + +7 { +res.has_is_rtmp = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_rtmp = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastbroadcastuploadstartednotification() CBroadcastBroadcastUploadStartedNotification { +return CBroadcastBroadcastUploadStartedNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastbroadcastuploadstartednotification(o CBroadcastBroadcastUploadStartedNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastbroadcastuploadstartednotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastBroadcastUploadStartedNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastbroadcastuploadstartednotification_unpack(v)? +return i, unpacked +} +pub struct CBroadcastStopBroadcastUploadNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +broadcast_id u64 +has_broadcast_id bool +broadcast_relay_id u64 +has_broadcast_relay_id bool +upload_result u32 +has_upload_result bool +too_many_poor_uploads bool +has_too_many_poor_uploads bool +} +pub fn (o &CBroadcastStopBroadcastUploadNotification) pack() []byte { +mut res := []byte{} +if o.has_broadcast_id { +res << vproto.pack_64bit_field(o.broadcast_id, 1) +} + +if o.has_broadcast_relay_id { +res << vproto.pack_64bit_field(o.broadcast_relay_id, 2) +} + +if o.has_upload_result { +res << vproto.pack_uint32_field(o.upload_result, 3) +} + +if o.has_too_many_poor_uploads { +res << vproto.pack_bool_field(o.too_many_poor_uploads, 4) +} + +return res +} + +pub fn cbroadcaststopbroadcastuploadnotification_unpack(buf []byte) ?CBroadcastStopBroadcastUploadNotification { +mut res := CBroadcastStopBroadcastUploadNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_broadcast_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_id = v +i = ii +} + +2 { +res.has_broadcast_relay_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_relay_id = v +i = ii +} + +3 { +res.has_upload_result = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.upload_result = v +i = ii +} + +4 { +res.has_too_many_poor_uploads = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.too_many_poor_uploads = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcaststopbroadcastuploadnotification() CBroadcastStopBroadcastUploadNotification { +return CBroadcastStopBroadcastUploadNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcaststopbroadcastuploadnotification(o CBroadcastStopBroadcastUploadNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcaststopbroadcastuploadnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastStopBroadcastUploadNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcaststopbroadcastuploadnotification_unpack(v)? +return i, unpacked +} +pub struct CBroadcastSessionClosedNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +broadcast_id u64 +has_broadcast_id bool +} +pub fn (o &CBroadcastSessionClosedNotification) pack() []byte { +mut res := []byte{} +if o.has_broadcast_id { +res << vproto.pack_64bit_field(o.broadcast_id, 1) +} + +return res +} + +pub fn cbroadcastsessionclosednotification_unpack(buf []byte) ?CBroadcastSessionClosedNotification { +mut res := CBroadcastSessionClosedNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_broadcast_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastsessionclosednotification() CBroadcastSessionClosedNotification { +return CBroadcastSessionClosedNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastsessionclosednotification(o CBroadcastSessionClosedNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastsessionclosednotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastSessionClosedNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastsessionclosednotification_unpack(v)? +return i, unpacked +} +pub struct CBroadcastViewerBroadcastInviteNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +broadcaster_steamid u64 +has_broadcaster_steamid bool +} +pub fn (o &CBroadcastViewerBroadcastInviteNotification) pack() []byte { +mut res := []byte{} +if o.has_broadcaster_steamid { +res << vproto.pack_64bit_field(o.broadcaster_steamid, 1) +} + +return res +} + +pub fn cbroadcastviewerbroadcastinvitenotification_unpack(buf []byte) ?CBroadcastViewerBroadcastInviteNotification { +mut res := CBroadcastViewerBroadcastInviteNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_broadcaster_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcaster_steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastviewerbroadcastinvitenotification() CBroadcastViewerBroadcastInviteNotification { +return CBroadcastViewerBroadcastInviteNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastviewerbroadcastinvitenotification(o CBroadcastViewerBroadcastInviteNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastviewerbroadcastinvitenotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastViewerBroadcastInviteNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastviewerbroadcastinvitenotification_unpack(v)? +return i, unpacked +} +pub struct CBroadcastBroadcastStatusNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +broadcast_id u64 +has_broadcast_id bool +num_viewers int +has_num_viewers bool +} +pub fn (o &CBroadcastBroadcastStatusNotification) pack() []byte { +mut res := []byte{} +if o.has_broadcast_id { +res << vproto.pack_64bit_field(o.broadcast_id, 1) +} + +if o.has_num_viewers { +res << vproto.pack_int32_field(o.num_viewers, 2) +} + +return res +} + +pub fn cbroadcastbroadcaststatusnotification_unpack(buf []byte) ?CBroadcastBroadcastStatusNotification { +mut res := CBroadcastBroadcastStatusNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_broadcast_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_id = v +i = ii +} + +2 { +res.has_num_viewers = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.num_viewers = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastbroadcaststatusnotification() CBroadcastBroadcastStatusNotification { +return CBroadcastBroadcastStatusNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastbroadcaststatusnotification(o CBroadcastBroadcastStatusNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastbroadcaststatusnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastBroadcastStatusNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastbroadcaststatusnotification_unpack(v)? +return i, unpacked +} +pub struct CBroadcastBroadcastChannelLiveNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +broadcast_channel_id u64 +has_broadcast_channel_id bool +broadcast_channel_name string +has_broadcast_channel_name bool +broadcast_channel_avatar string +has_broadcast_channel_avatar bool +} +pub fn (o &CBroadcastBroadcastChannelLiveNotification) pack() []byte { +mut res := []byte{} +if o.has_broadcast_channel_id { +res << vproto.pack_64bit_field(o.broadcast_channel_id, 1) +} + +if o.has_broadcast_channel_name { +res << vproto.pack_string_field(o.broadcast_channel_name, 2) +} + +if o.has_broadcast_channel_avatar { +res << vproto.pack_string_field(o.broadcast_channel_avatar, 3) +} + +return res +} + +pub fn cbroadcastbroadcastchannellivenotification_unpack(buf []byte) ?CBroadcastBroadcastChannelLiveNotification { +mut res := CBroadcastBroadcastChannelLiveNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_broadcast_channel_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_channel_id = v +i = ii +} + +2 { +res.has_broadcast_channel_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_channel_name = v +i = ii +} + +3 { +res.has_broadcast_channel_avatar = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_channel_avatar = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastbroadcastchannellivenotification() CBroadcastBroadcastChannelLiveNotification { +return CBroadcastBroadcastChannelLiveNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastbroadcastchannellivenotification(o CBroadcastBroadcastChannelLiveNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastbroadcastchannellivenotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastBroadcastChannelLiveNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastbroadcastchannellivenotification_unpack(v)? +return i, unpacked +} +pub struct CBroadcastSendThumbnailToRelayNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +thumbnail_upload_token string +has_thumbnail_upload_token bool +thumbnail_broadcast_session_id u64 +has_thumbnail_broadcast_session_id bool +thumbnail_data []byte +has_thumbnail_data bool +thumbnail_width u32 +has_thumbnail_width bool +thumbnail_height u32 +has_thumbnail_height bool +} +pub fn (o &CBroadcastSendThumbnailToRelayNotification) pack() []byte { +mut res := []byte{} +if o.has_thumbnail_upload_token { +res << vproto.pack_string_field(o.thumbnail_upload_token, 1) +} + +if o.has_thumbnail_broadcast_session_id { +res << vproto.pack_64bit_field(o.thumbnail_broadcast_session_id, 2) +} + +if o.has_thumbnail_data { +res << vproto.pack_bytes_field(o.thumbnail_data, 3) +} + +if o.has_thumbnail_width { +res << vproto.pack_uint32_field(o.thumbnail_width, 4) +} + +if o.has_thumbnail_height { +res << vproto.pack_uint32_field(o.thumbnail_height, 5) +} + +return res +} + +pub fn cbroadcastsendthumbnailtorelaynotification_unpack(buf []byte) ?CBroadcastSendThumbnailToRelayNotification { +mut res := CBroadcastSendThumbnailToRelayNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_thumbnail_upload_token = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.thumbnail_upload_token = v +i = ii +} + +2 { +res.has_thumbnail_broadcast_session_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.thumbnail_broadcast_session_id = v +i = ii +} + +3 { +res.has_thumbnail_data = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.thumbnail_data = v +i = ii +} + +4 { +res.has_thumbnail_width = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.thumbnail_width = v +i = ii +} + +5 { +res.has_thumbnail_height = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.thumbnail_height = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastsendthumbnailtorelaynotification() CBroadcastSendThumbnailToRelayNotification { +return CBroadcastSendThumbnailToRelayNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastsendthumbnailtorelaynotification(o CBroadcastSendThumbnailToRelayNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastsendthumbnailtorelaynotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastSendThumbnailToRelayNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastsendthumbnailtorelaynotification_unpack(v)? +return i, unpacked +} +pub struct CBroadcastWebRTcneedTUrnserverNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +broadcast_session_id u64 +has_broadcast_session_id bool +} +pub fn (o &CBroadcastWebRTcneedTUrnserverNotification) pack() []byte { +mut res := []byte{} +if o.has_broadcast_session_id { +res << vproto.pack_64bit_field(o.broadcast_session_id, 1) +} + +return res +} + +pub fn cbroadcastwebrtcneedturnservernotification_unpack(buf []byte) ?CBroadcastWebRTcneedTUrnserverNotification { +mut res := CBroadcastWebRTcneedTUrnserverNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_broadcast_session_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_session_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastwebrtcneedturnservernotification() CBroadcastWebRTcneedTUrnserverNotification { +return CBroadcastWebRTcneedTUrnserverNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastwebrtcneedturnservernotification(o CBroadcastWebRTcneedTUrnserverNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastwebrtcneedturnservernotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastWebRTcneedTUrnserverNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastwebrtcneedturnservernotification_unpack(v)? +return i, unpacked +} +pub struct CBroadcastWebRTcstartNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +broadcast_session_id u64 +has_broadcast_session_id bool +webrtc_session_id u64 +has_webrtc_session_id bool +viewer_steamid u64 +has_viewer_steamid bool +viewer_token u64 +has_viewer_token bool +} +pub fn (o &CBroadcastWebRTcstartNotification) pack() []byte { +mut res := []byte{} +if o.has_broadcast_session_id { +res << vproto.pack_64bit_field(o.broadcast_session_id, 1) +} + +if o.has_webrtc_session_id { +res << vproto.pack_64bit_field(o.webrtc_session_id, 2) +} + +if o.has_viewer_steamid { +res << vproto.pack_64bit_field(o.viewer_steamid, 3) +} + +if o.has_viewer_token { +res << vproto.pack_64bit_field(o.viewer_token, 4) +} + +return res +} + +pub fn cbroadcastwebrtcstartnotification_unpack(buf []byte) ?CBroadcastWebRTcstartNotification { +mut res := CBroadcastWebRTcstartNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_broadcast_session_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_session_id = v +i = ii +} + +2 { +res.has_webrtc_session_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.webrtc_session_id = v +i = ii +} + +3 { +res.has_viewer_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.viewer_steamid = v +i = ii +} + +4 { +res.has_viewer_token = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.viewer_token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastwebrtcstartnotification() CBroadcastWebRTcstartNotification { +return CBroadcastWebRTcstartNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastwebrtcstartnotification(o CBroadcastWebRTcstartNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastwebrtcstartnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastWebRTcstartNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastwebrtcstartnotification_unpack(v)? +return i, unpacked +} +pub struct CBroadcastWebRTcsetAnswerNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +broadcast_session_id u64 +has_broadcast_session_id bool +webrtc_session_id u64 +has_webrtc_session_id bool +answer string +has_answer bool +} +pub fn (o &CBroadcastWebRTcsetAnswerNotification) pack() []byte { +mut res := []byte{} +if o.has_broadcast_session_id { +res << vproto.pack_64bit_field(o.broadcast_session_id, 1) +} + +if o.has_webrtc_session_id { +res << vproto.pack_64bit_field(o.webrtc_session_id, 2) +} + +if o.has_answer { +res << vproto.pack_string_field(o.answer, 3) +} + +return res +} + +pub fn cbroadcastwebrtcsetanswernotification_unpack(buf []byte) ?CBroadcastWebRTcsetAnswerNotification { +mut res := CBroadcastWebRTcsetAnswerNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_broadcast_session_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_session_id = v +i = ii +} + +2 { +res.has_webrtc_session_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.webrtc_session_id = v +i = ii +} + +3 { +res.has_answer = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.answer = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastwebrtcsetanswernotification() CBroadcastWebRTcsetAnswerNotification { +return CBroadcastWebRTcsetAnswerNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastwebrtcsetanswernotification(o CBroadcastWebRTcsetAnswerNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastwebrtcsetanswernotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastWebRTcsetAnswerNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastwebrtcsetanswernotification_unpack(v)? +return i, unpacked +} +pub struct CBroadcastWebRTcaddViewerCandidateNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +broadcast_session_id u64 +has_broadcast_session_id bool +webrtc_session_id u64 +has_webrtc_session_id bool +candidate CBroadcastWebRTccandidate +has_candidate bool +} +pub fn (o &CBroadcastWebRTcaddViewerCandidateNotification) pack() []byte { +mut res := []byte{} +if o.has_broadcast_session_id { +res << vproto.pack_64bit_field(o.broadcast_session_id, 1) +} + +if o.has_webrtc_session_id { +res << vproto.pack_64bit_field(o.webrtc_session_id, 2) +} + +if o.has_candidate { +res << zzz_vproto_internal_pack_cbroadcastwebrtccandidate(o.candidate, 3) +} + +return res +} + +pub fn cbroadcastwebrtcaddviewercandidatenotification_unpack(buf []byte) ?CBroadcastWebRTcaddViewerCandidateNotification { +mut res := CBroadcastWebRTcaddViewerCandidateNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_broadcast_session_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_session_id = v +i = ii +} + +2 { +res.has_webrtc_session_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.webrtc_session_id = v +i = ii +} + +3 { +res.has_candidate = true +ii, v := zzz_vproto_internal_unpack_cbroadcastwebrtccandidate(cur_buf, tag_wiretype.wire_type)? +res.candidate = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cbroadcastwebrtcaddviewercandidatenotification() CBroadcastWebRTcaddViewerCandidateNotification { +return CBroadcastWebRTcaddViewerCandidateNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cbroadcastwebrtcaddviewercandidatenotification(o CBroadcastWebRTcaddViewerCandidateNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cbroadcastwebrtcaddviewercandidatenotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CBroadcastWebRTcaddViewerCandidateNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cbroadcastwebrtcaddviewercandidatenotification_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_chat.steamclient_pb.v b/proto/steammessages_chat.steamclient_pb.v new file mode 100644 index 0000000..d724ed3 --- /dev/null +++ b/proto/steammessages_chat.steamclient_pb.v @@ -0,0 +1,11786 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +[_allow_multiple_values] +enum EChatRoomJoinState { +k_echatroomjoinstate_default = 0 +k_echatroomjoinstate_none = 1 +k_echatroomjoinstate_joined = 2 +k_echatroomjoinstate_testinvalid = 99 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_echatroomjoinstate(e EChatRoomJoinState, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_echatroomjoinstate(buf []byte, tag_wiretype vproto.WireType) ?(int, EChatRoomJoinState) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EChatRoomJoinState(v) +} +[_allow_multiple_values] +enum EChatRoomGroupRank { +k_echatroomgrouprank_default = 0 +k_echatroomgrouprank_viewer = 10 +k_echatroomgrouprank_guest = 15 +k_echatroomgrouprank_member = 20 +k_echatroomgrouprank_moderator = 30 +k_echatroomgrouprank_officer = 40 +k_echatroomgrouprank_owner = 50 +k_echatroomgrouprank_testinvalid = 99 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_echatroomgrouprank(e EChatRoomGroupRank, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_echatroomgrouprank(buf []byte, tag_wiretype vproto.WireType) ?(int, EChatRoomGroupRank) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EChatRoomGroupRank(v) +} +[_allow_multiple_values] +enum EChatRoomNotificationLevel { +k_echatroomnotificationlevel_invalid = 0 +k_echatroomnotificationlevel_none = 1 +k_echatroomnotificationlevel_mentionme = 2 +k_echatroomnotificationlevel_mentionall = 3 +k_echatroomnotificationlevel_allmessages = 4 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_echatroomnotificationlevel(e EChatRoomNotificationLevel, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_echatroomnotificationlevel(buf []byte, tag_wiretype vproto.WireType) ?(int, EChatRoomNotificationLevel) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EChatRoomNotificationLevel(v) +} +[_allow_multiple_values] +enum EChatRoomServerMessage { +k_echatroomservermsg_invalid = 0 +k_echatroomservermsg_renamechatroom = 1 +k_echatroomservermsg_joined = 2 +k_echatroomservermsg_parted = 3 +k_echatroomservermsg_kicked = 4 +k_echatroomservermsg_invited = 5 +k_echatroomservermsg_invitedismissed = 8 +k_echatroomservermsg_chatroomtaglinechanged = 9 +k_echatroomservermsg_chatroomavatarchanged = 10 +k_echatroomservermsg_appcustom = 11 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_echatroomservermessage(e EChatRoomServerMessage, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_echatroomservermessage(buf []byte, tag_wiretype vproto.WireType) ?(int, EChatRoomServerMessage) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EChatRoomServerMessage(v) +} +[_allow_multiple_values] +enum EChatRoomMemberStateChange { +k_echatroommemberstatechange_invalid = 0 +k_echatroommemberstatechange_joined = 1 +k_echatroommemberstatechange_parted = 2 +k_echatroommemberstatechange_kicked = 3 +k_echatroommemberstatechange_invited = 4 +k_echatroommemberstatechange_rankchanged = 7 +k_echatroommemberstatechange_invitedismissed = 8 +k_echatroommemberstatechange_muted = 9 +k_echatroommemberstatechange_banned = 10 +k_echatroommemberstatechange_roleschanged = 12 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_echatroommemberstatechange(e EChatRoomMemberStateChange, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_echatroommemberstatechange(buf []byte, tag_wiretype vproto.WireType) ?(int, EChatRoomMemberStateChange) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EChatRoomMemberStateChange(v) +} +pub struct CChatRequestFriendPersonaStatesRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CChatRequestFriendPersonaStatesRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn cchatrequestfriendpersonastatesrequest_unpack(buf []byte) ?CChatRequestFriendPersonaStatesRequest { +res := CChatRequestFriendPersonaStatesRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatrequestfriendpersonastatesrequest() CChatRequestFriendPersonaStatesRequest { +return CChatRequestFriendPersonaStatesRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatrequestfriendpersonastatesrequest(o CChatRequestFriendPersonaStatesRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatrequestfriendpersonastatesrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRequestFriendPersonaStatesRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatrequestfriendpersonastatesrequest_unpack(v)? +return i, unpacked +} +pub struct CChatRequestFriendPersonaStatesResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CChatRequestFriendPersonaStatesResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cchatrequestfriendpersonastatesresponse_unpack(buf []byte) ?CChatRequestFriendPersonaStatesResponse { +res := CChatRequestFriendPersonaStatesResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatrequestfriendpersonastatesresponse() CChatRequestFriendPersonaStatesResponse { +return CChatRequestFriendPersonaStatesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatrequestfriendpersonastatesresponse(o CChatRequestFriendPersonaStatesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatrequestfriendpersonastatesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRequestFriendPersonaStatesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatrequestfriendpersonastatesresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomCreateChatRoomGroupRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid_partner u64 +has_steamid_partner bool +steamid_invited u64 +has_steamid_invited bool +name string +has_name bool +steamid_invitees []u64 +watching_broadcast_accountid u32 +has_watching_broadcast_accountid bool +watching_broadcast_channel_id u64 +has_watching_broadcast_channel_id bool +} +pub fn (o &CChatRoomCreateChatRoomGroupRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid_partner { +res << vproto.pack_64bit_field(o.steamid_partner, 1) +} + +if o.has_steamid_invited { +res << vproto.pack_64bit_field(o.steamid_invited, 2) +} + +if o.has_name { +res << vproto.pack_string_field(o.name, 3) +} + +// [packed=false] +for _, x in o.steamid_invitees { +res << vproto.pack_64bit_field(x, 4) +} + +if o.has_watching_broadcast_accountid { +res << vproto.pack_uint32_field(o.watching_broadcast_accountid, 6) +} + +if o.has_watching_broadcast_channel_id { +res << vproto.pack_uint64_field(o.watching_broadcast_channel_id, 7) +} + +return res +} + +pub fn cchatroomcreatechatroomgrouprequest_unpack(buf []byte) ?CChatRoomCreateChatRoomGroupRequest { +mut res := CChatRoomCreateChatRoomGroupRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid_partner = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_partner = v +i = ii +} + +2 { +res.has_steamid_invited = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_invited = v +i = ii +} + +3 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +4 { +// [packed=false] +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_invitees << v +i = ii +} + +6 { +res.has_watching_broadcast_accountid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.watching_broadcast_accountid = v +i = ii +} + +7 { +res.has_watching_broadcast_channel_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.watching_broadcast_channel_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomcreatechatroomgrouprequest() CChatRoomCreateChatRoomGroupRequest { +return CChatRoomCreateChatRoomGroupRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomcreatechatroomgrouprequest(o CChatRoomCreateChatRoomGroupRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomcreatechatroomgrouprequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomCreateChatRoomGroupRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomcreatechatroomgrouprequest_unpack(v)? +return i, unpacked +} +pub struct CChatRole { +mut: +unknown_fields []vproto.UnknownField +pub mut: +role_id u64 +has_role_id bool +name string +has_name bool +ordinal u32 +has_ordinal bool +} +pub fn (o &CChatRole) pack() []byte { +mut res := []byte{} +if o.has_role_id { +res << vproto.pack_uint64_field(o.role_id, 1) +} + +if o.has_name { +res << vproto.pack_string_field(o.name, 2) +} + +if o.has_ordinal { +res << vproto.pack_uint32_field(o.ordinal, 3) +} + +return res +} + +pub fn cchatrole_unpack(buf []byte) ?CChatRole { +mut res := CChatRole{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_role_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.role_id = v +i = ii +} + +2 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +3 { +res.has_ordinal = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ordinal = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatrole() CChatRole { +return CChatRole{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatrole(o CChatRole, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatrole(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRole) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatrole_unpack(v)? +return i, unpacked +} +pub struct CChatRoleActions { +mut: +unknown_fields []vproto.UnknownField +pub mut: +role_id u64 +has_role_id bool +can_create_rename_delete_channel bool +has_can_create_rename_delete_channel bool +can_kick bool +has_can_kick bool +can_ban bool +has_can_ban bool +can_invite bool +has_can_invite bool +can_change_tagline_avatar_name bool +has_can_change_tagline_avatar_name bool +can_chat bool +has_can_chat bool +can_view_history bool +has_can_view_history bool +can_change_group_roles bool +has_can_change_group_roles bool +can_change_user_roles bool +has_can_change_user_roles bool +can_mention_all bool +has_can_mention_all bool +can_set_watching_broadcast bool +has_can_set_watching_broadcast bool +} +pub fn (o &CChatRoleActions) pack() []byte { +mut res := []byte{} +if o.has_role_id { +res << vproto.pack_uint64_field(o.role_id, 1) +} + +if o.has_can_create_rename_delete_channel { +res << vproto.pack_bool_field(o.can_create_rename_delete_channel, 2) +} + +if o.has_can_kick { +res << vproto.pack_bool_field(o.can_kick, 3) +} + +if o.has_can_ban { +res << vproto.pack_bool_field(o.can_ban, 4) +} + +if o.has_can_invite { +res << vproto.pack_bool_field(o.can_invite, 5) +} + +if o.has_can_change_tagline_avatar_name { +res << vproto.pack_bool_field(o.can_change_tagline_avatar_name, 6) +} + +if o.has_can_chat { +res << vproto.pack_bool_field(o.can_chat, 7) +} + +if o.has_can_view_history { +res << vproto.pack_bool_field(o.can_view_history, 8) +} + +if o.has_can_change_group_roles { +res << vproto.pack_bool_field(o.can_change_group_roles, 9) +} + +if o.has_can_change_user_roles { +res << vproto.pack_bool_field(o.can_change_user_roles, 10) +} + +if o.has_can_mention_all { +res << vproto.pack_bool_field(o.can_mention_all, 11) +} + +if o.has_can_set_watching_broadcast { +res << vproto.pack_bool_field(o.can_set_watching_broadcast, 12) +} + +return res +} + +pub fn cchatroleactions_unpack(buf []byte) ?CChatRoleActions { +mut res := CChatRoleActions{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_role_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.role_id = v +i = ii +} + +2 { +res.has_can_create_rename_delete_channel = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.can_create_rename_delete_channel = v +i = ii +} + +3 { +res.has_can_kick = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.can_kick = v +i = ii +} + +4 { +res.has_can_ban = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.can_ban = v +i = ii +} + +5 { +res.has_can_invite = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.can_invite = v +i = ii +} + +6 { +res.has_can_change_tagline_avatar_name = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.can_change_tagline_avatar_name = v +i = ii +} + +7 { +res.has_can_chat = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.can_chat = v +i = ii +} + +8 { +res.has_can_view_history = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.can_view_history = v +i = ii +} + +9 { +res.has_can_change_group_roles = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.can_change_group_roles = v +i = ii +} + +10 { +res.has_can_change_user_roles = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.can_change_user_roles = v +i = ii +} + +11 { +res.has_can_mention_all = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.can_mention_all = v +i = ii +} + +12 { +res.has_can_set_watching_broadcast = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.can_set_watching_broadcast = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroleactions() CChatRoleActions { +return CChatRoleActions{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroleactions(o CChatRoleActions, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroleactions(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoleActions) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroleactions_unpack(v)? +return i, unpacked +} +pub struct CChatPartyBeacon { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +steamid_owner u64 +has_steamid_owner bool +beacon_id u64 +has_beacon_id bool +game_metadata string +has_game_metadata bool +} +pub fn (o &CChatPartyBeacon) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_steamid_owner { +res << vproto.pack_64bit_field(o.steamid_owner, 2) +} + +if o.has_beacon_id { +res << vproto.pack_64bit_field(o.beacon_id, 3) +} + +if o.has_game_metadata { +res << vproto.pack_string_field(o.game_metadata, 4) +} + +return res +} + +pub fn cchatpartybeacon_unpack(buf []byte) ?CChatPartyBeacon { +mut res := CChatPartyBeacon{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_steamid_owner = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_owner = v +i = ii +} + +3 { +res.has_beacon_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.beacon_id = v +i = ii +} + +4 { +res.has_game_metadata = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.game_metadata = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatpartybeacon() CChatPartyBeacon { +return CChatPartyBeacon{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatpartybeacon(o CChatPartyBeacon, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatpartybeacon(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatPartyBeacon) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatpartybeacon_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGroupHeaderState { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +chat_name string +has_chat_name bool +clanid u32 +has_clanid bool +accountid_owner u32 +has_accountid_owner bool +appid u32 +has_appid bool +tagline string +has_tagline bool +avatar_sha []byte +has_avatar_sha bool +default_role_id u64 +has_default_role_id bool +roles []CChatRole +role_actions []CChatRoleActions +watching_broadcast_accountid u32 +has_watching_broadcast_accountid bool +party_beacons []CChatPartyBeacon +watching_broadcast_channel_id u64 +has_watching_broadcast_channel_id bool +active_minigame_id u64 +has_active_minigame_id bool +avatar_ugc_url string +has_avatar_ugc_url bool +} +pub fn (o &CChatRoomGroupHeaderState) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_chat_name { +res << vproto.pack_string_field(o.chat_name, 2) +} + +if o.has_clanid { +res << vproto.pack_uint32_field(o.clanid, 13) +} + +if o.has_accountid_owner { +res << vproto.pack_uint32_field(o.accountid_owner, 14) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 21) +} + +if o.has_tagline { +res << vproto.pack_string_field(o.tagline, 15) +} + +if o.has_avatar_sha { +res << vproto.pack_bytes_field(o.avatar_sha, 16) +} + +if o.has_default_role_id { +res << vproto.pack_uint64_field(o.default_role_id, 17) +} + +// [packed=false] +for _, x in o.roles { +res << zzz_vproto_internal_pack_cchatrole(x, 18) +} + +// [packed=false] +for _, x in o.role_actions { +res << zzz_vproto_internal_pack_cchatroleactions(x, 19) +} + +if o.has_watching_broadcast_accountid { +res << vproto.pack_uint32_field(o.watching_broadcast_accountid, 20) +} + +// [packed=false] +for _, x in o.party_beacons { +res << zzz_vproto_internal_pack_cchatpartybeacon(x, 22) +} + +if o.has_watching_broadcast_channel_id { +res << vproto.pack_uint64_field(o.watching_broadcast_channel_id, 23) +} + +if o.has_active_minigame_id { +res << vproto.pack_uint64_field(o.active_minigame_id, 24) +} + +if o.has_avatar_ugc_url { +res << vproto.pack_string_field(o.avatar_ugc_url, 25) +} + +return res +} + +pub fn cchatroomgroupheaderstate_unpack(buf []byte) ?CChatRoomGroupHeaderState { +mut res := CChatRoomGroupHeaderState{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_chat_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.chat_name = v +i = ii +} + +13 { +res.has_clanid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.clanid = v +i = ii +} + +14 { +res.has_accountid_owner = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.accountid_owner = v +i = ii +} + +21 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +15 { +res.has_tagline = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.tagline = v +i = ii +} + +16 { +res.has_avatar_sha = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.avatar_sha = v +i = ii +} + +17 { +res.has_default_role_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.default_role_id = v +i = ii +} + +18 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cchatrole(cur_buf, tag_wiretype.wire_type)? +res.roles << v +i = ii +} + +19 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cchatroleactions(cur_buf, tag_wiretype.wire_type)? +res.role_actions << v +i = ii +} + +20 { +res.has_watching_broadcast_accountid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.watching_broadcast_accountid = v +i = ii +} + +22 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cchatpartybeacon(cur_buf, tag_wiretype.wire_type)? +res.party_beacons << v +i = ii +} + +23 { +res.has_watching_broadcast_channel_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.watching_broadcast_channel_id = v +i = ii +} + +24 { +res.has_active_minigame_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.active_minigame_id = v +i = ii +} + +25 { +res.has_avatar_ugc_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.avatar_ugc_url = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgroupheaderstate() CChatRoomGroupHeaderState { +return CChatRoomGroupHeaderState{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgroupheaderstate(o CChatRoomGroupHeaderState, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgroupheaderstate(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGroupHeaderState) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgroupheaderstate_unpack(v)? +return i, unpacked +} +pub struct CChatRoomMember { +mut: +unknown_fields []vproto.UnknownField +pub mut: +accountid u32 +has_accountid bool +state EChatRoomJoinState +has_state bool +rank EChatRoomGroupRank +has_rank bool +time_kick_expire u32 +has_time_kick_expire bool +role_ids []u64 +} +pub fn (o &CChatRoomMember) pack() []byte { +mut res := []byte{} +if o.has_accountid { +res << vproto.pack_uint32_field(o.accountid, 1) +} + +if o.has_state { +res << zzz_vproto_internal_pack_echatroomjoinstate(o.state, 3) +} + +if o.has_rank { +res << zzz_vproto_internal_pack_echatroomgrouprank(o.rank, 4) +} + +if o.has_time_kick_expire { +res << vproto.pack_uint32_field(o.time_kick_expire, 6) +} + +// [packed=false] +for _, x in o.role_ids { +res << vproto.pack_uint64_field(x, 7) +} + +return res +} + +pub fn cchatroommember_unpack(buf []byte) ?CChatRoomMember { +mut res := CChatRoomMember{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_accountid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.accountid = v +i = ii +} + +3 { +res.has_state = true +ii, v := zzz_vproto_internal_unpack_echatroomjoinstate(cur_buf, tag_wiretype.wire_type)? +res.state = v +i = ii +} + +4 { +res.has_rank = true +ii, v := zzz_vproto_internal_unpack_echatroomgrouprank(cur_buf, tag_wiretype.wire_type)? +res.rank = v +i = ii +} + +6 { +res.has_time_kick_expire = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_kick_expire = v +i = ii +} + +7 { +// [packed=false] +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.role_ids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroommember() CChatRoomMember { +return CChatRoomMember{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroommember(o CChatRoomMember, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroommember(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomMember) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroommember_unpack(v)? +return i, unpacked +} +pub struct CChatRoomState { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_id u64 +has_chat_id bool +chat_name string +has_chat_name bool +voice_allowed bool +has_voice_allowed bool +members_in_voice []u32 +time_last_message u32 +has_time_last_message bool +sort_order u32 +has_sort_order bool +last_message string +has_last_message bool +accountid_last_message u32 +has_accountid_last_message bool +} +pub fn (o &CChatRoomState) pack() []byte { +mut res := []byte{} +if o.has_chat_id { +res << vproto.pack_uint64_field(o.chat_id, 1) +} + +if o.has_chat_name { +res << vproto.pack_string_field(o.chat_name, 2) +} + +if o.has_voice_allowed { +res << vproto.pack_bool_field(o.voice_allowed, 3) +} + +// [packed=false] +for _, x in o.members_in_voice { +res << vproto.pack_uint32_field(x, 4) +} + +if o.has_time_last_message { +res << vproto.pack_uint32_field(o.time_last_message, 5) +} + +if o.has_sort_order { +res << vproto.pack_uint32_field(o.sort_order, 6) +} + +if o.has_last_message { +res << vproto.pack_string_field(o.last_message, 7) +} + +if o.has_accountid_last_message { +res << vproto.pack_uint32_field(o.accountid_last_message, 8) +} + +return res +} + +pub fn cchatroomstate_unpack(buf []byte) ?CChatRoomState { +mut res := CChatRoomState{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +2 { +res.has_chat_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.chat_name = v +i = ii +} + +3 { +res.has_voice_allowed = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.voice_allowed = v +i = ii +} + +4 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.members_in_voice << v +i = ii +} + +5 { +res.has_time_last_message = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_last_message = v +i = ii +} + +6 { +res.has_sort_order = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.sort_order = v +i = ii +} + +7 { +res.has_last_message = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.last_message = v +i = ii +} + +8 { +res.has_accountid_last_message = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.accountid_last_message = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomstate() CChatRoomState { +return CChatRoomState{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomstate(o CChatRoomState, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomstate(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomState) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomstate_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGroupState { +mut: +unknown_fields []vproto.UnknownField +pub mut: +header_state CChatRoomGroupHeaderState +has_header_state bool +members []CChatRoomMember +default_chat_id u64 +has_default_chat_id bool +chat_rooms []CChatRoomState +kicked []CChatRoomMember +} +pub fn (o &CChatRoomGroupState) pack() []byte { +mut res := []byte{} +if o.has_header_state { +res << zzz_vproto_internal_pack_cchatroomgroupheaderstate(o.header_state, 1) +} + +// [packed=false] +for _, x in o.members { +res << zzz_vproto_internal_pack_cchatroommember(x, 2) +} + +if o.has_default_chat_id { +res << vproto.pack_uint64_field(o.default_chat_id, 4) +} + +// [packed=false] +for _, x in o.chat_rooms { +res << zzz_vproto_internal_pack_cchatroomstate(x, 5) +} + +// [packed=false] +for _, x in o.kicked { +res << zzz_vproto_internal_pack_cchatroommember(x, 7) +} + +return res +} + +pub fn cchatroomgroupstate_unpack(buf []byte) ?CChatRoomGroupState { +mut res := CChatRoomGroupState{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_header_state = true +ii, v := zzz_vproto_internal_unpack_cchatroomgroupheaderstate(cur_buf, tag_wiretype.wire_type)? +res.header_state = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cchatroommember(cur_buf, tag_wiretype.wire_type)? +res.members << v +i = ii +} + +4 { +res.has_default_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.default_chat_id = v +i = ii +} + +5 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cchatroomstate(cur_buf, tag_wiretype.wire_type)? +res.chat_rooms << v +i = ii +} + +7 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cchatroommember(cur_buf, tag_wiretype.wire_type)? +res.kicked << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgroupstate() CChatRoomGroupState { +return CChatRoomGroupState{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgroupstate(o CChatRoomGroupState, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgroupstate(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGroupState) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgroupstate_unpack(v)? +return i, unpacked +} +pub struct CUserChatRoomState { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_id u64 +has_chat_id bool +time_joined u32 +has_time_joined bool +time_last_ack u32 +has_time_last_ack bool +desktop_notification_level EChatRoomNotificationLevel +has_desktop_notification_level bool +mobile_notification_level EChatRoomNotificationLevel +has_mobile_notification_level bool +time_last_mention u32 +has_time_last_mention bool +unread_indicator_muted bool +has_unread_indicator_muted bool +time_first_unread u32 +has_time_first_unread bool +} +pub fn (o &CUserChatRoomState) pack() []byte { +mut res := []byte{} +if o.has_chat_id { +res << vproto.pack_uint64_field(o.chat_id, 1) +} + +if o.has_time_joined { +res << vproto.pack_uint32_field(o.time_joined, 2) +} + +if o.has_time_last_ack { +res << vproto.pack_uint32_field(o.time_last_ack, 3) +} + +if o.has_desktop_notification_level { +res << zzz_vproto_internal_pack_echatroomnotificationlevel(o.desktop_notification_level, 4) +} + +if o.has_mobile_notification_level { +res << zzz_vproto_internal_pack_echatroomnotificationlevel(o.mobile_notification_level, 5) +} + +if o.has_time_last_mention { +res << vproto.pack_uint32_field(o.time_last_mention, 6) +} + +if o.has_unread_indicator_muted { +res << vproto.pack_bool_field(o.unread_indicator_muted, 7) +} + +if o.has_time_first_unread { +res << vproto.pack_uint32_field(o.time_first_unread, 8) +} + +return res +} + +pub fn cuserchatroomstate_unpack(buf []byte) ?CUserChatRoomState { +mut res := CUserChatRoomState{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +2 { +res.has_time_joined = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_joined = v +i = ii +} + +3 { +res.has_time_last_ack = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_last_ack = v +i = ii +} + +4 { +res.has_desktop_notification_level = true +ii, v := zzz_vproto_internal_unpack_echatroomnotificationlevel(cur_buf, tag_wiretype.wire_type)? +res.desktop_notification_level = v +i = ii +} + +5 { +res.has_mobile_notification_level = true +ii, v := zzz_vproto_internal_unpack_echatroomnotificationlevel(cur_buf, tag_wiretype.wire_type)? +res.mobile_notification_level = v +i = ii +} + +6 { +res.has_time_last_mention = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_last_mention = v +i = ii +} + +7 { +res.has_unread_indicator_muted = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.unread_indicator_muted = v +i = ii +} + +8 { +res.has_time_first_unread = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_first_unread = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cuserchatroomstate() CUserChatRoomState { +return CUserChatRoomState{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cuserchatroomstate(o CUserChatRoomState, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cuserchatroomstate(buf []byte, tag_wiretype vproto.WireType) ?(int, CUserChatRoomState) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cuserchatroomstate_unpack(v)? +return i, unpacked +} +pub struct CUserChatRoomGroupState { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +time_joined u32 +has_time_joined bool +user_chat_room_state []CUserChatRoomState +desktop_notification_level EChatRoomNotificationLevel +has_desktop_notification_level bool +mobile_notification_level EChatRoomNotificationLevel +has_mobile_notification_level bool +time_last_group_ack u32 +has_time_last_group_ack bool +unread_indicator_muted bool +has_unread_indicator_muted bool +} +pub fn (o &CUserChatRoomGroupState) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_time_joined { +res << vproto.pack_uint32_field(o.time_joined, 2) +} + +// [packed=false] +for _, x in o.user_chat_room_state { +res << zzz_vproto_internal_pack_cuserchatroomstate(x, 3) +} + +if o.has_desktop_notification_level { +res << zzz_vproto_internal_pack_echatroomnotificationlevel(o.desktop_notification_level, 4) +} + +if o.has_mobile_notification_level { +res << zzz_vproto_internal_pack_echatroomnotificationlevel(o.mobile_notification_level, 5) +} + +if o.has_time_last_group_ack { +res << vproto.pack_uint32_field(o.time_last_group_ack, 6) +} + +if o.has_unread_indicator_muted { +res << vproto.pack_bool_field(o.unread_indicator_muted, 7) +} + +return res +} + +pub fn cuserchatroomgroupstate_unpack(buf []byte) ?CUserChatRoomGroupState { +mut res := CUserChatRoomGroupState{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_time_joined = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_joined = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cuserchatroomstate(cur_buf, tag_wiretype.wire_type)? +res.user_chat_room_state << v +i = ii +} + +4 { +res.has_desktop_notification_level = true +ii, v := zzz_vproto_internal_unpack_echatroomnotificationlevel(cur_buf, tag_wiretype.wire_type)? +res.desktop_notification_level = v +i = ii +} + +5 { +res.has_mobile_notification_level = true +ii, v := zzz_vproto_internal_unpack_echatroomnotificationlevel(cur_buf, tag_wiretype.wire_type)? +res.mobile_notification_level = v +i = ii +} + +6 { +res.has_time_last_group_ack = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_last_group_ack = v +i = ii +} + +7 { +res.has_unread_indicator_muted = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.unread_indicator_muted = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cuserchatroomgroupstate() CUserChatRoomGroupState { +return CUserChatRoomGroupState{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cuserchatroomgroupstate(o CUserChatRoomGroupState, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cuserchatroomgroupstate(buf []byte, tag_wiretype vproto.WireType) ?(int, CUserChatRoomGroupState) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cuserchatroomgroupstate_unpack(v)? +return i, unpacked +} +pub struct CChatRoomCreateChatRoomGroupResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +state CChatRoomGroupState +has_state bool +user_chat_state CUserChatRoomGroupState +has_user_chat_state bool +} +pub fn (o &CChatRoomCreateChatRoomGroupResponse) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_state { +res << zzz_vproto_internal_pack_cchatroomgroupstate(o.state, 2) +} + +if o.has_user_chat_state { +res << zzz_vproto_internal_pack_cuserchatroomgroupstate(o.user_chat_state, 3) +} + +return res +} + +pub fn cchatroomcreatechatroomgroupresponse_unpack(buf []byte) ?CChatRoomCreateChatRoomGroupResponse { +mut res := CChatRoomCreateChatRoomGroupResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_state = true +ii, v := zzz_vproto_internal_unpack_cchatroomgroupstate(cur_buf, tag_wiretype.wire_type)? +res.state = v +i = ii +} + +3 { +res.has_user_chat_state = true +ii, v := zzz_vproto_internal_unpack_cuserchatroomgroupstate(cur_buf, tag_wiretype.wire_type)? +res.user_chat_state = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomcreatechatroomgroupresponse() CChatRoomCreateChatRoomGroupResponse { +return CChatRoomCreateChatRoomGroupResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomcreatechatroomgroupresponse(o CChatRoomCreateChatRoomGroupResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomcreatechatroomgroupresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomCreateChatRoomGroupResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomcreatechatroomgroupresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomSaveChatRoomGroupRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +name string +has_name bool +} +pub fn (o &CChatRoomSaveChatRoomGroupRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_name { +res << vproto.pack_string_field(o.name, 2) +} + +return res +} + +pub fn cchatroomsavechatroomgrouprequest_unpack(buf []byte) ?CChatRoomSaveChatRoomGroupRequest { +mut res := CChatRoomSaveChatRoomGroupRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomsavechatroomgrouprequest() CChatRoomSaveChatRoomGroupRequest { +return CChatRoomSaveChatRoomGroupRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomsavechatroomgrouprequest(o CChatRoomSaveChatRoomGroupRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomsavechatroomgrouprequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomSaveChatRoomGroupRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomsavechatroomgrouprequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomSaveChatRoomGroupResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CChatRoomSaveChatRoomGroupResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cchatroomsavechatroomgroupresponse_unpack(buf []byte) ?CChatRoomSaveChatRoomGroupResponse { +res := CChatRoomSaveChatRoomGroupResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomsavechatroomgroupresponse() CChatRoomSaveChatRoomGroupResponse { +return CChatRoomSaveChatRoomGroupResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomsavechatroomgroupresponse(o CChatRoomSaveChatRoomGroupResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomsavechatroomgroupresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomSaveChatRoomGroupResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomsavechatroomgroupresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomRenameChatRoomGroupRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +name string +has_name bool +} +pub fn (o &CChatRoomRenameChatRoomGroupRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_name { +res << vproto.pack_string_field(o.name, 2) +} + +return res +} + +pub fn cchatroomrenamechatroomgrouprequest_unpack(buf []byte) ?CChatRoomRenameChatRoomGroupRequest { +mut res := CChatRoomRenameChatRoomGroupRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomrenamechatroomgrouprequest() CChatRoomRenameChatRoomGroupRequest { +return CChatRoomRenameChatRoomGroupRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomrenamechatroomgrouprequest(o CChatRoomRenameChatRoomGroupRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomrenamechatroomgrouprequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomRenameChatRoomGroupRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomrenamechatroomgrouprequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomRenameChatRoomGroupResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +name string +has_name bool +} +pub fn (o &CChatRoomRenameChatRoomGroupResponse) pack() []byte { +mut res := []byte{} +if o.has_name { +res << vproto.pack_string_field(o.name, 1) +} + +return res +} + +pub fn cchatroomrenamechatroomgroupresponse_unpack(buf []byte) ?CChatRoomRenameChatRoomGroupResponse { +mut res := CChatRoomRenameChatRoomGroupResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomrenamechatroomgroupresponse() CChatRoomRenameChatRoomGroupResponse { +return CChatRoomRenameChatRoomGroupResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomrenamechatroomgroupresponse(o CChatRoomRenameChatRoomGroupResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomrenamechatroomgroupresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomRenameChatRoomGroupResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomrenamechatroomgroupresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomSetChatRoomGroupTaglineRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +tagline string +has_tagline bool +} +pub fn (o &CChatRoomSetChatRoomGroupTaglineRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_tagline { +res << vproto.pack_string_field(o.tagline, 2) +} + +return res +} + +pub fn cchatroomsetchatroomgrouptaglinerequest_unpack(buf []byte) ?CChatRoomSetChatRoomGroupTaglineRequest { +mut res := CChatRoomSetChatRoomGroupTaglineRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_tagline = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.tagline = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomsetchatroomgrouptaglinerequest() CChatRoomSetChatRoomGroupTaglineRequest { +return CChatRoomSetChatRoomGroupTaglineRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomsetchatroomgrouptaglinerequest(o CChatRoomSetChatRoomGroupTaglineRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomsetchatroomgrouptaglinerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomSetChatRoomGroupTaglineRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomsetchatroomgrouptaglinerequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomSetChatRoomGroupTaglineResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CChatRoomSetChatRoomGroupTaglineResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cchatroomsetchatroomgrouptaglineresponse_unpack(buf []byte) ?CChatRoomSetChatRoomGroupTaglineResponse { +res := CChatRoomSetChatRoomGroupTaglineResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomsetchatroomgrouptaglineresponse() CChatRoomSetChatRoomGroupTaglineResponse { +return CChatRoomSetChatRoomGroupTaglineResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomsetchatroomgrouptaglineresponse(o CChatRoomSetChatRoomGroupTaglineResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomsetchatroomgrouptaglineresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomSetChatRoomGroupTaglineResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomsetchatroomgrouptaglineresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomSetChatRoomGroupAvatarRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +avatar_sha []byte +has_avatar_sha bool +} +pub fn (o &CChatRoomSetChatRoomGroupAvatarRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_avatar_sha { +res << vproto.pack_bytes_field(o.avatar_sha, 2) +} + +return res +} + +pub fn cchatroomsetchatroomgroupavatarrequest_unpack(buf []byte) ?CChatRoomSetChatRoomGroupAvatarRequest { +mut res := CChatRoomSetChatRoomGroupAvatarRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_avatar_sha = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.avatar_sha = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomsetchatroomgroupavatarrequest() CChatRoomSetChatRoomGroupAvatarRequest { +return CChatRoomSetChatRoomGroupAvatarRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomsetchatroomgroupavatarrequest(o CChatRoomSetChatRoomGroupAvatarRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomsetchatroomgroupavatarrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomSetChatRoomGroupAvatarRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomsetchatroomgroupavatarrequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomSetChatRoomGroupAvatarResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CChatRoomSetChatRoomGroupAvatarResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cchatroomsetchatroomgroupavatarresponse_unpack(buf []byte) ?CChatRoomSetChatRoomGroupAvatarResponse { +res := CChatRoomSetChatRoomGroupAvatarResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomsetchatroomgroupavatarresponse() CChatRoomSetChatRoomGroupAvatarResponse { +return CChatRoomSetChatRoomGroupAvatarResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomsetchatroomgroupavatarresponse(o CChatRoomSetChatRoomGroupAvatarResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomsetchatroomgroupavatarresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomSetChatRoomGroupAvatarResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomsetchatroomgroupavatarresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomSetChatRoomGroupWatchingBroadcastRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +watching_broadcast_accountid u32 +has_watching_broadcast_accountid bool +watching_broadcast_channel_id u64 +has_watching_broadcast_channel_id bool +} +pub fn (o &CChatRoomSetChatRoomGroupWatchingBroadcastRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_watching_broadcast_accountid { +res << vproto.pack_uint32_field(o.watching_broadcast_accountid, 2) +} + +if o.has_watching_broadcast_channel_id { +res << vproto.pack_uint64_field(o.watching_broadcast_channel_id, 3) +} + +return res +} + +pub fn cchatroomsetchatroomgroupwatchingbroadcastrequest_unpack(buf []byte) ?CChatRoomSetChatRoomGroupWatchingBroadcastRequest { +mut res := CChatRoomSetChatRoomGroupWatchingBroadcastRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_watching_broadcast_accountid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.watching_broadcast_accountid = v +i = ii +} + +3 { +res.has_watching_broadcast_channel_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.watching_broadcast_channel_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomsetchatroomgroupwatchingbroadcastrequest() CChatRoomSetChatRoomGroupWatchingBroadcastRequest { +return CChatRoomSetChatRoomGroupWatchingBroadcastRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomsetchatroomgroupwatchingbroadcastrequest(o CChatRoomSetChatRoomGroupWatchingBroadcastRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomsetchatroomgroupwatchingbroadcastrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomSetChatRoomGroupWatchingBroadcastRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomsetchatroomgroupwatchingbroadcastrequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomSetChatRoomGroupWatchingBroadcastResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CChatRoomSetChatRoomGroupWatchingBroadcastResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cchatroomsetchatroomgroupwatchingbroadcastresponse_unpack(buf []byte) ?CChatRoomSetChatRoomGroupWatchingBroadcastResponse { +res := CChatRoomSetChatRoomGroupWatchingBroadcastResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomsetchatroomgroupwatchingbroadcastresponse() CChatRoomSetChatRoomGroupWatchingBroadcastResponse { +return CChatRoomSetChatRoomGroupWatchingBroadcastResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomsetchatroomgroupwatchingbroadcastresponse(o CChatRoomSetChatRoomGroupWatchingBroadcastResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomsetchatroomgroupwatchingbroadcastresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomSetChatRoomGroupWatchingBroadcastResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomsetchatroomgroupwatchingbroadcastresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomJoinMiniGameForChatRoomGroupRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +chat_id u64 +has_chat_id bool +} +pub fn (o &CChatRoomJoinMiniGameForChatRoomGroupRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_chat_id { +res << vproto.pack_uint64_field(o.chat_id, 2) +} + +return res +} + +pub fn cchatroomjoinminigameforchatroomgrouprequest_unpack(buf []byte) ?CChatRoomJoinMiniGameForChatRoomGroupRequest { +mut res := CChatRoomJoinMiniGameForChatRoomGroupRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomjoinminigameforchatroomgrouprequest() CChatRoomJoinMiniGameForChatRoomGroupRequest { +return CChatRoomJoinMiniGameForChatRoomGroupRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomjoinminigameforchatroomgrouprequest(o CChatRoomJoinMiniGameForChatRoomGroupRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomjoinminigameforchatroomgrouprequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomJoinMiniGameForChatRoomGroupRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomjoinminigameforchatroomgrouprequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomJoinMiniGameForChatRoomGroupResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +minigame_id u64 +has_minigame_id bool +} +pub fn (o &CChatRoomJoinMiniGameForChatRoomGroupResponse) pack() []byte { +mut res := []byte{} +if o.has_minigame_id { +res << vproto.pack_uint64_field(o.minigame_id, 1) +} + +return res +} + +pub fn cchatroomjoinminigameforchatroomgroupresponse_unpack(buf []byte) ?CChatRoomJoinMiniGameForChatRoomGroupResponse { +mut res := CChatRoomJoinMiniGameForChatRoomGroupResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_minigame_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.minigame_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomjoinminigameforchatroomgroupresponse() CChatRoomJoinMiniGameForChatRoomGroupResponse { +return CChatRoomJoinMiniGameForChatRoomGroupResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomjoinminigameforchatroomgroupresponse(o CChatRoomJoinMiniGameForChatRoomGroupResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomjoinminigameforchatroomgroupresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomJoinMiniGameForChatRoomGroupResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomjoinminigameforchatroomgroupresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomEndMiniGameForChatRoomGroupRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +chat_id u64 +has_chat_id bool +minigame_id u64 +has_minigame_id bool +} +pub fn (o &CChatRoomEndMiniGameForChatRoomGroupRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_chat_id { +res << vproto.pack_uint64_field(o.chat_id, 2) +} + +if o.has_minigame_id { +res << vproto.pack_uint64_field(o.minigame_id, 3) +} + +return res +} + +pub fn cchatroomendminigameforchatroomgrouprequest_unpack(buf []byte) ?CChatRoomEndMiniGameForChatRoomGroupRequest { +mut res := CChatRoomEndMiniGameForChatRoomGroupRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +3 { +res.has_minigame_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.minigame_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomendminigameforchatroomgrouprequest() CChatRoomEndMiniGameForChatRoomGroupRequest { +return CChatRoomEndMiniGameForChatRoomGroupRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomendminigameforchatroomgrouprequest(o CChatRoomEndMiniGameForChatRoomGroupRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomendminigameforchatroomgrouprequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomEndMiniGameForChatRoomGroupRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomendminigameforchatroomgrouprequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomEndMiniGameForChatRoomGroupResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CChatRoomEndMiniGameForChatRoomGroupResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cchatroomendminigameforchatroomgroupresponse_unpack(buf []byte) ?CChatRoomEndMiniGameForChatRoomGroupResponse { +res := CChatRoomEndMiniGameForChatRoomGroupResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomendminigameforchatroomgroupresponse() CChatRoomEndMiniGameForChatRoomGroupResponse { +return CChatRoomEndMiniGameForChatRoomGroupResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomendminigameforchatroomgroupresponse(o CChatRoomEndMiniGameForChatRoomGroupResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomendminigameforchatroomgroupresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomEndMiniGameForChatRoomGroupResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomendminigameforchatroomgroupresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomMuteUserRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +steamid u64 +has_steamid bool +expiration int +has_expiration bool +} +pub fn (o &CChatRoomMuteUserRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 2) +} + +if o.has_expiration { +res << vproto.pack_int32_field(o.expiration, 3) +} + +return res +} + +pub fn cchatroommuteuserrequest_unpack(buf []byte) ?CChatRoomMuteUserRequest { +mut res := CChatRoomMuteUserRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +3 { +res.has_expiration = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.expiration = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroommuteuserrequest() CChatRoomMuteUserRequest { +return CChatRoomMuteUserRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroommuteuserrequest(o CChatRoomMuteUserRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroommuteuserrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomMuteUserRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroommuteuserrequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomMuteUserResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CChatRoomMuteUserResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cchatroommuteuserresponse_unpack(buf []byte) ?CChatRoomMuteUserResponse { +res := CChatRoomMuteUserResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroommuteuserresponse() CChatRoomMuteUserResponse { +return CChatRoomMuteUserResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroommuteuserresponse(o CChatRoomMuteUserResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroommuteuserresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomMuteUserResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroommuteuserresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomKickUserRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +steamid u64 +has_steamid bool +expiration int +has_expiration bool +} +pub fn (o &CChatRoomKickUserRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 2) +} + +if o.has_expiration { +res << vproto.pack_int32_field(o.expiration, 3) +} + +return res +} + +pub fn cchatroomkickuserrequest_unpack(buf []byte) ?CChatRoomKickUserRequest { +mut res := CChatRoomKickUserRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +3 { +res.has_expiration = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.expiration = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomkickuserrequest() CChatRoomKickUserRequest { +return CChatRoomKickUserRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomkickuserrequest(o CChatRoomKickUserRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomkickuserrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomKickUserRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomkickuserrequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomKickUserResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CChatRoomKickUserResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cchatroomkickuserresponse_unpack(buf []byte) ?CChatRoomKickUserResponse { +res := CChatRoomKickUserResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomkickuserresponse() CChatRoomKickUserResponse { +return CChatRoomKickUserResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomkickuserresponse(o CChatRoomKickUserResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomkickuserresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomKickUserResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomkickuserresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomSetUserBanStateRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +steamid u64 +has_steamid bool +ban_state bool +has_ban_state bool +} +pub fn (o &CChatRoomSetUserBanStateRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 2) +} + +if o.has_ban_state { +res << vproto.pack_bool_field(o.ban_state, 3) +} + +return res +} + +pub fn cchatroomsetuserbanstaterequest_unpack(buf []byte) ?CChatRoomSetUserBanStateRequest { +mut res := CChatRoomSetUserBanStateRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +3 { +res.has_ban_state = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.ban_state = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomsetuserbanstaterequest() CChatRoomSetUserBanStateRequest { +return CChatRoomSetUserBanStateRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomsetuserbanstaterequest(o CChatRoomSetUserBanStateRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomsetuserbanstaterequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomSetUserBanStateRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomsetuserbanstaterequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomSetUserBanStateResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CChatRoomSetUserBanStateResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cchatroomsetuserbanstateresponse_unpack(buf []byte) ?CChatRoomSetUserBanStateResponse { +res := CChatRoomSetUserBanStateResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomsetuserbanstateresponse() CChatRoomSetUserBanStateResponse { +return CChatRoomSetUserBanStateResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomsetuserbanstateresponse(o CChatRoomSetUserBanStateResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomsetuserbanstateresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomSetUserBanStateResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomsetuserbanstateresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomRevokeInviteRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +steamid u64 +has_steamid bool +} +pub fn (o &CChatRoomRevokeInviteRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 2) +} + +return res +} + +pub fn cchatroomrevokeinviterequest_unpack(buf []byte) ?CChatRoomRevokeInviteRequest { +mut res := CChatRoomRevokeInviteRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomrevokeinviterequest() CChatRoomRevokeInviteRequest { +return CChatRoomRevokeInviteRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomrevokeinviterequest(o CChatRoomRevokeInviteRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomrevokeinviterequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomRevokeInviteRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomrevokeinviterequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomRevokeInviteResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CChatRoomRevokeInviteResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cchatroomrevokeinviteresponse_unpack(buf []byte) ?CChatRoomRevokeInviteResponse { +res := CChatRoomRevokeInviteResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomrevokeinviteresponse() CChatRoomRevokeInviteResponse { +return CChatRoomRevokeInviteResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomrevokeinviteresponse(o CChatRoomRevokeInviteResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomrevokeinviteresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomRevokeInviteResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomrevokeinviteresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomCreateRoleRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +name string +has_name bool +} +pub fn (o &CChatRoomCreateRoleRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_name { +res << vproto.pack_string_field(o.name, 2) +} + +return res +} + +pub fn cchatroomcreaterolerequest_unpack(buf []byte) ?CChatRoomCreateRoleRequest { +mut res := CChatRoomCreateRoleRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomcreaterolerequest() CChatRoomCreateRoleRequest { +return CChatRoomCreateRoleRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomcreaterolerequest(o CChatRoomCreateRoleRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomcreaterolerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomCreateRoleRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomcreaterolerequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomCreateRoleResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +actions CChatRoleActions +has_actions bool +} +pub fn (o &CChatRoomCreateRoleResponse) pack() []byte { +mut res := []byte{} +if o.has_actions { +res << zzz_vproto_internal_pack_cchatroleactions(o.actions, 2) +} + +return res +} + +pub fn cchatroomcreateroleresponse_unpack(buf []byte) ?CChatRoomCreateRoleResponse { +mut res := CChatRoomCreateRoleResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +2 { +res.has_actions = true +ii, v := zzz_vproto_internal_unpack_cchatroleactions(cur_buf, tag_wiretype.wire_type)? +res.actions = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomcreateroleresponse() CChatRoomCreateRoleResponse { +return CChatRoomCreateRoleResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomcreateroleresponse(o CChatRoomCreateRoleResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomcreateroleresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomCreateRoleResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomcreateroleresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGetRolesRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +} +pub fn (o &CChatRoomGetRolesRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +return res +} + +pub fn cchatroomgetrolesrequest_unpack(buf []byte) ?CChatRoomGetRolesRequest { +mut res := CChatRoomGetRolesRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgetrolesrequest() CChatRoomGetRolesRequest { +return CChatRoomGetRolesRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgetrolesrequest(o CChatRoomGetRolesRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgetrolesrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGetRolesRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgetrolesrequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGetRolesResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +roles []CChatRole +} +pub fn (o &CChatRoomGetRolesResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.roles { +res << zzz_vproto_internal_pack_cchatrole(x, 1) +} + +return res +} + +pub fn cchatroomgetrolesresponse_unpack(buf []byte) ?CChatRoomGetRolesResponse { +mut res := CChatRoomGetRolesResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cchatrole(cur_buf, tag_wiretype.wire_type)? +res.roles << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgetrolesresponse() CChatRoomGetRolesResponse { +return CChatRoomGetRolesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgetrolesresponse(o CChatRoomGetRolesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgetrolesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGetRolesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgetrolesresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomRenameRoleRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +role_id u64 +has_role_id bool +name string +has_name bool +} +pub fn (o &CChatRoomRenameRoleRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_role_id { +res << vproto.pack_uint64_field(o.role_id, 2) +} + +if o.has_name { +res << vproto.pack_string_field(o.name, 3) +} + +return res +} + +pub fn cchatroomrenamerolerequest_unpack(buf []byte) ?CChatRoomRenameRoleRequest { +mut res := CChatRoomRenameRoleRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_role_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.role_id = v +i = ii +} + +3 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomrenamerolerequest() CChatRoomRenameRoleRequest { +return CChatRoomRenameRoleRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomrenamerolerequest(o CChatRoomRenameRoleRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomrenamerolerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomRenameRoleRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomrenamerolerequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomRenameRoleResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CChatRoomRenameRoleResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cchatroomrenameroleresponse_unpack(buf []byte) ?CChatRoomRenameRoleResponse { +res := CChatRoomRenameRoleResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomrenameroleresponse() CChatRoomRenameRoleResponse { +return CChatRoomRenameRoleResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomrenameroleresponse(o CChatRoomRenameRoleResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomrenameroleresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomRenameRoleResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomrenameroleresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomReorderRoleRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +role_id u64 +has_role_id bool +ordinal u32 +has_ordinal bool +} +pub fn (o &CChatRoomReorderRoleRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_role_id { +res << vproto.pack_uint64_field(o.role_id, 2) +} + +if o.has_ordinal { +res << vproto.pack_uint32_field(o.ordinal, 3) +} + +return res +} + +pub fn cchatroomreorderrolerequest_unpack(buf []byte) ?CChatRoomReorderRoleRequest { +mut res := CChatRoomReorderRoleRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_role_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.role_id = v +i = ii +} + +3 { +res.has_ordinal = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ordinal = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomreorderrolerequest() CChatRoomReorderRoleRequest { +return CChatRoomReorderRoleRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomreorderrolerequest(o CChatRoomReorderRoleRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomreorderrolerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomReorderRoleRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomreorderrolerequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomReorderRoleResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CChatRoomReorderRoleResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cchatroomreorderroleresponse_unpack(buf []byte) ?CChatRoomReorderRoleResponse { +res := CChatRoomReorderRoleResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomreorderroleresponse() CChatRoomReorderRoleResponse { +return CChatRoomReorderRoleResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomreorderroleresponse(o CChatRoomReorderRoleResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomreorderroleresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomReorderRoleResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomreorderroleresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomDeleteRoleRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +role_id u64 +has_role_id bool +} +pub fn (o &CChatRoomDeleteRoleRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_role_id { +res << vproto.pack_uint64_field(o.role_id, 2) +} + +return res +} + +pub fn cchatroomdeleterolerequest_unpack(buf []byte) ?CChatRoomDeleteRoleRequest { +mut res := CChatRoomDeleteRoleRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_role_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.role_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomdeleterolerequest() CChatRoomDeleteRoleRequest { +return CChatRoomDeleteRoleRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomdeleterolerequest(o CChatRoomDeleteRoleRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomdeleterolerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomDeleteRoleRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomdeleterolerequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomDeleteRoleResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CChatRoomDeleteRoleResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cchatroomdeleteroleresponse_unpack(buf []byte) ?CChatRoomDeleteRoleResponse { +res := CChatRoomDeleteRoleResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomdeleteroleresponse() CChatRoomDeleteRoleResponse { +return CChatRoomDeleteRoleResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomdeleteroleresponse(o CChatRoomDeleteRoleResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomdeleteroleresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomDeleteRoleResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomdeleteroleresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGetRoleActionsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +role_id u64 +has_role_id bool +} +pub fn (o &CChatRoomGetRoleActionsRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_role_id { +res << vproto.pack_uint64_field(o.role_id, 2) +} + +return res +} + +pub fn cchatroomgetroleactionsrequest_unpack(buf []byte) ?CChatRoomGetRoleActionsRequest { +mut res := CChatRoomGetRoleActionsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_role_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.role_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgetroleactionsrequest() CChatRoomGetRoleActionsRequest { +return CChatRoomGetRoleActionsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgetroleactionsrequest(o CChatRoomGetRoleActionsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgetroleactionsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGetRoleActionsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgetroleactionsrequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGetRoleActionsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +actions []CChatRoleActions +} +pub fn (o &CChatRoomGetRoleActionsResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.actions { +res << zzz_vproto_internal_pack_cchatroleactions(x, 1) +} + +return res +} + +pub fn cchatroomgetroleactionsresponse_unpack(buf []byte) ?CChatRoomGetRoleActionsResponse { +mut res := CChatRoomGetRoleActionsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cchatroleactions(cur_buf, tag_wiretype.wire_type)? +res.actions << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgetroleactionsresponse() CChatRoomGetRoleActionsResponse { +return CChatRoomGetRoleActionsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgetroleactionsresponse(o CChatRoomGetRoleActionsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgetroleactionsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGetRoleActionsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgetroleactionsresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomReplaceRoleActionsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +role_id u64 +has_role_id bool +actions CChatRoleActions +has_actions bool +} +pub fn (o &CChatRoomReplaceRoleActionsRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_role_id { +res << vproto.pack_uint64_field(o.role_id, 2) +} + +if o.has_actions { +res << zzz_vproto_internal_pack_cchatroleactions(o.actions, 4) +} + +return res +} + +pub fn cchatroomreplaceroleactionsrequest_unpack(buf []byte) ?CChatRoomReplaceRoleActionsRequest { +mut res := CChatRoomReplaceRoleActionsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_role_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.role_id = v +i = ii +} + +4 { +res.has_actions = true +ii, v := zzz_vproto_internal_unpack_cchatroleactions(cur_buf, tag_wiretype.wire_type)? +res.actions = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomreplaceroleactionsrequest() CChatRoomReplaceRoleActionsRequest { +return CChatRoomReplaceRoleActionsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomreplaceroleactionsrequest(o CChatRoomReplaceRoleActionsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomreplaceroleactionsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomReplaceRoleActionsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomreplaceroleactionsrequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomReplaceRoleActionsResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CChatRoomReplaceRoleActionsResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cchatroomreplaceroleactionsresponse_unpack(buf []byte) ?CChatRoomReplaceRoleActionsResponse { +res := CChatRoomReplaceRoleActionsResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomreplaceroleactionsresponse() CChatRoomReplaceRoleActionsResponse { +return CChatRoomReplaceRoleActionsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomreplaceroleactionsresponse(o CChatRoomReplaceRoleActionsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomreplaceroleactionsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomReplaceRoleActionsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomreplaceroleactionsresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomAddRoleToUserRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +role_id u64 +has_role_id bool +steamid u64 +has_steamid bool +} +pub fn (o &CChatRoomAddRoleToUserRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_role_id { +res << vproto.pack_uint64_field(o.role_id, 3) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 4) +} + +return res +} + +pub fn cchatroomaddroletouserrequest_unpack(buf []byte) ?CChatRoomAddRoleToUserRequest { +mut res := CChatRoomAddRoleToUserRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +3 { +res.has_role_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.role_id = v +i = ii +} + +4 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomaddroletouserrequest() CChatRoomAddRoleToUserRequest { +return CChatRoomAddRoleToUserRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomaddroletouserrequest(o CChatRoomAddRoleToUserRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomaddroletouserrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomAddRoleToUserRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomaddroletouserrequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomAddRoleToUserResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CChatRoomAddRoleToUserResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cchatroomaddroletouserresponse_unpack(buf []byte) ?CChatRoomAddRoleToUserResponse { +res := CChatRoomAddRoleToUserResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomaddroletouserresponse() CChatRoomAddRoleToUserResponse { +return CChatRoomAddRoleToUserResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomaddroletouserresponse(o CChatRoomAddRoleToUserResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomaddroletouserresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomAddRoleToUserResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomaddroletouserresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGetRolesForUserRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +steamid u64 +has_steamid bool +} +pub fn (o &CChatRoomGetRolesForUserRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 3) +} + +return res +} + +pub fn cchatroomgetrolesforuserrequest_unpack(buf []byte) ?CChatRoomGetRolesForUserRequest { +mut res := CChatRoomGetRolesForUserRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +3 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgetrolesforuserrequest() CChatRoomGetRolesForUserRequest { +return CChatRoomGetRolesForUserRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgetrolesforuserrequest(o CChatRoomGetRolesForUserRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgetrolesforuserrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGetRolesForUserRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgetrolesforuserrequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGetRolesForUserResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +role_ids []u64 +} +pub fn (o &CChatRoomGetRolesForUserResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.role_ids { +res << vproto.pack_uint64_field(x, 1) +} + +return res +} + +pub fn cchatroomgetrolesforuserresponse_unpack(buf []byte) ?CChatRoomGetRolesForUserResponse { +mut res := CChatRoomGetRolesForUserResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.role_ids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgetrolesforuserresponse() CChatRoomGetRolesForUserResponse { +return CChatRoomGetRolesForUserResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgetrolesforuserresponse(o CChatRoomGetRolesForUserResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgetrolesforuserresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGetRolesForUserResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgetrolesforuserresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomDeleteRoleFromUserRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +role_id u64 +has_role_id bool +steamid u64 +has_steamid bool +} +pub fn (o &CChatRoomDeleteRoleFromUserRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_role_id { +res << vproto.pack_uint64_field(o.role_id, 3) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 4) +} + +return res +} + +pub fn cchatroomdeleterolefromuserrequest_unpack(buf []byte) ?CChatRoomDeleteRoleFromUserRequest { +mut res := CChatRoomDeleteRoleFromUserRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +3 { +res.has_role_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.role_id = v +i = ii +} + +4 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomdeleterolefromuserrequest() CChatRoomDeleteRoleFromUserRequest { +return CChatRoomDeleteRoleFromUserRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomdeleterolefromuserrequest(o CChatRoomDeleteRoleFromUserRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomdeleterolefromuserrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomDeleteRoleFromUserRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomdeleterolefromuserrequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomDeleteRoleFromUserResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CChatRoomDeleteRoleFromUserResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cchatroomdeleterolefromuserresponse_unpack(buf []byte) ?CChatRoomDeleteRoleFromUserResponse { +res := CChatRoomDeleteRoleFromUserResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomdeleterolefromuserresponse() CChatRoomDeleteRoleFromUserResponse { +return CChatRoomDeleteRoleFromUserResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomdeleterolefromuserresponse(o CChatRoomDeleteRoleFromUserResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomdeleterolefromuserresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomDeleteRoleFromUserResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomdeleterolefromuserresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomJoinChatRoomGroupRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +invite_code string +has_invite_code bool +chat_id u64 +has_chat_id bool +} +pub fn (o &CChatRoomJoinChatRoomGroupRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_invite_code { +res << vproto.pack_string_field(o.invite_code, 2) +} + +if o.has_chat_id { +res << vproto.pack_uint64_field(o.chat_id, 3) +} + +return res +} + +pub fn cchatroomjoinchatroomgrouprequest_unpack(buf []byte) ?CChatRoomJoinChatRoomGroupRequest { +mut res := CChatRoomJoinChatRoomGroupRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_invite_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.invite_code = v +i = ii +} + +3 { +res.has_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomjoinchatroomgrouprequest() CChatRoomJoinChatRoomGroupRequest { +return CChatRoomJoinChatRoomGroupRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomjoinchatroomgrouprequest(o CChatRoomJoinChatRoomGroupRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomjoinchatroomgrouprequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomJoinChatRoomGroupRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomjoinchatroomgrouprequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomJoinChatRoomGroupResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +state CChatRoomGroupState +has_state bool +user_chat_state CUserChatRoomGroupState +has_user_chat_state bool +join_chat_id u64 +has_join_chat_id bool +time_expire u32 +has_time_expire bool +} +pub fn (o &CChatRoomJoinChatRoomGroupResponse) pack() []byte { +mut res := []byte{} +if o.has_state { +res << zzz_vproto_internal_pack_cchatroomgroupstate(o.state, 1) +} + +if o.has_user_chat_state { +res << zzz_vproto_internal_pack_cuserchatroomgroupstate(o.user_chat_state, 3) +} + +if o.has_join_chat_id { +res << vproto.pack_uint64_field(o.join_chat_id, 4) +} + +if o.has_time_expire { +res << vproto.pack_uint32_field(o.time_expire, 5) +} + +return res +} + +pub fn cchatroomjoinchatroomgroupresponse_unpack(buf []byte) ?CChatRoomJoinChatRoomGroupResponse { +mut res := CChatRoomJoinChatRoomGroupResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_state = true +ii, v := zzz_vproto_internal_unpack_cchatroomgroupstate(cur_buf, tag_wiretype.wire_type)? +res.state = v +i = ii +} + +3 { +res.has_user_chat_state = true +ii, v := zzz_vproto_internal_unpack_cuserchatroomgroupstate(cur_buf, tag_wiretype.wire_type)? +res.user_chat_state = v +i = ii +} + +4 { +res.has_join_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.join_chat_id = v +i = ii +} + +5 { +res.has_time_expire = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_expire = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomjoinchatroomgroupresponse() CChatRoomJoinChatRoomGroupResponse { +return CChatRoomJoinChatRoomGroupResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomjoinchatroomgroupresponse(o CChatRoomJoinChatRoomGroupResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomjoinchatroomgroupresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomJoinChatRoomGroupResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomjoinchatroomgroupresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomInviteFriendToChatRoomGroupRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +steamid u64 +has_steamid bool +chat_id u64 +has_chat_id bool +skip_friendsui_check bool +has_skip_friendsui_check bool +} +pub fn (o &CChatRoomInviteFriendToChatRoomGroupRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 2) +} + +if o.has_chat_id { +res << vproto.pack_uint64_field(o.chat_id, 3) +} + +if o.has_skip_friendsui_check { +res << vproto.pack_bool_field(o.skip_friendsui_check, 4) +} + +return res +} + +pub fn cchatroominvitefriendtochatroomgrouprequest_unpack(buf []byte) ?CChatRoomInviteFriendToChatRoomGroupRequest { +mut res := CChatRoomInviteFriendToChatRoomGroupRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +3 { +res.has_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +4 { +res.has_skip_friendsui_check = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.skip_friendsui_check = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroominvitefriendtochatroomgrouprequest() CChatRoomInviteFriendToChatRoomGroupRequest { +return CChatRoomInviteFriendToChatRoomGroupRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroominvitefriendtochatroomgrouprequest(o CChatRoomInviteFriendToChatRoomGroupRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroominvitefriendtochatroomgrouprequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomInviteFriendToChatRoomGroupRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroominvitefriendtochatroomgrouprequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomInviteFriendToChatRoomGroupResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CChatRoomInviteFriendToChatRoomGroupResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cchatroominvitefriendtochatroomgroupresponse_unpack(buf []byte) ?CChatRoomInviteFriendToChatRoomGroupResponse { +res := CChatRoomInviteFriendToChatRoomGroupResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroominvitefriendtochatroomgroupresponse() CChatRoomInviteFriendToChatRoomGroupResponse { +return CChatRoomInviteFriendToChatRoomGroupResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroominvitefriendtochatroomgroupresponse(o CChatRoomInviteFriendToChatRoomGroupResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroominvitefriendtochatroomgroupresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomInviteFriendToChatRoomGroupResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroominvitefriendtochatroomgroupresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomLeaveChatRoomGroupRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +} +pub fn (o &CChatRoomLeaveChatRoomGroupRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +return res +} + +pub fn cchatroomleavechatroomgrouprequest_unpack(buf []byte) ?CChatRoomLeaveChatRoomGroupRequest { +mut res := CChatRoomLeaveChatRoomGroupRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomleavechatroomgrouprequest() CChatRoomLeaveChatRoomGroupRequest { +return CChatRoomLeaveChatRoomGroupRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomleavechatroomgrouprequest(o CChatRoomLeaveChatRoomGroupRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomleavechatroomgrouprequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomLeaveChatRoomGroupRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomleavechatroomgrouprequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomLeaveChatRoomGroupResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CChatRoomLeaveChatRoomGroupResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cchatroomleavechatroomgroupresponse_unpack(buf []byte) ?CChatRoomLeaveChatRoomGroupResponse { +res := CChatRoomLeaveChatRoomGroupResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomleavechatroomgroupresponse() CChatRoomLeaveChatRoomGroupResponse { +return CChatRoomLeaveChatRoomGroupResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomleavechatroomgroupresponse(o CChatRoomLeaveChatRoomGroupResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomleavechatroomgroupresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomLeaveChatRoomGroupResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomleavechatroomgroupresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomCreateChatRoomRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +name string +has_name bool +allow_voice bool +has_allow_voice bool +} +pub fn (o &CChatRoomCreateChatRoomRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_name { +res << vproto.pack_string_field(o.name, 2) +} + +if o.has_allow_voice { +res << vproto.pack_bool_field(o.allow_voice, 3) +} + +return res +} + +pub fn cchatroomcreatechatroomrequest_unpack(buf []byte) ?CChatRoomCreateChatRoomRequest { +mut res := CChatRoomCreateChatRoomRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +3 { +res.has_allow_voice = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.allow_voice = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomcreatechatroomrequest() CChatRoomCreateChatRoomRequest { +return CChatRoomCreateChatRoomRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomcreatechatroomrequest(o CChatRoomCreateChatRoomRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomcreatechatroomrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomCreateChatRoomRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomcreatechatroomrequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomCreateChatRoomResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_room CChatRoomState +has_chat_room bool +} +pub fn (o &CChatRoomCreateChatRoomResponse) pack() []byte { +mut res := []byte{} +if o.has_chat_room { +res << zzz_vproto_internal_pack_cchatroomstate(o.chat_room, 1) +} + +return res +} + +pub fn cchatroomcreatechatroomresponse_unpack(buf []byte) ?CChatRoomCreateChatRoomResponse { +mut res := CChatRoomCreateChatRoomResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_room = true +ii, v := zzz_vproto_internal_unpack_cchatroomstate(cur_buf, tag_wiretype.wire_type)? +res.chat_room = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomcreatechatroomresponse() CChatRoomCreateChatRoomResponse { +return CChatRoomCreateChatRoomResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomcreatechatroomresponse(o CChatRoomCreateChatRoomResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomcreatechatroomresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomCreateChatRoomResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomcreatechatroomresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomDeleteChatRoomRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +chat_id u64 +has_chat_id bool +} +pub fn (o &CChatRoomDeleteChatRoomRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_chat_id { +res << vproto.pack_uint64_field(o.chat_id, 2) +} + +return res +} + +pub fn cchatroomdeletechatroomrequest_unpack(buf []byte) ?CChatRoomDeleteChatRoomRequest { +mut res := CChatRoomDeleteChatRoomRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomdeletechatroomrequest() CChatRoomDeleteChatRoomRequest { +return CChatRoomDeleteChatRoomRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomdeletechatroomrequest(o CChatRoomDeleteChatRoomRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomdeletechatroomrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomDeleteChatRoomRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomdeletechatroomrequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomDeleteChatRoomResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CChatRoomDeleteChatRoomResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cchatroomdeletechatroomresponse_unpack(buf []byte) ?CChatRoomDeleteChatRoomResponse { +res := CChatRoomDeleteChatRoomResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomdeletechatroomresponse() CChatRoomDeleteChatRoomResponse { +return CChatRoomDeleteChatRoomResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomdeletechatroomresponse(o CChatRoomDeleteChatRoomResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomdeletechatroomresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomDeleteChatRoomResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomdeletechatroomresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomRenameChatRoomRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +chat_id u64 +has_chat_id bool +name string +has_name bool +} +pub fn (o &CChatRoomRenameChatRoomRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_chat_id { +res << vproto.pack_uint64_field(o.chat_id, 2) +} + +if o.has_name { +res << vproto.pack_string_field(o.name, 3) +} + +return res +} + +pub fn cchatroomrenamechatroomrequest_unpack(buf []byte) ?CChatRoomRenameChatRoomRequest { +mut res := CChatRoomRenameChatRoomRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +3 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomrenamechatroomrequest() CChatRoomRenameChatRoomRequest { +return CChatRoomRenameChatRoomRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomrenamechatroomrequest(o CChatRoomRenameChatRoomRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomrenamechatroomrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomRenameChatRoomRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomrenamechatroomrequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomRenameChatRoomResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CChatRoomRenameChatRoomResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cchatroomrenamechatroomresponse_unpack(buf []byte) ?CChatRoomRenameChatRoomResponse { +res := CChatRoomRenameChatRoomResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomrenamechatroomresponse() CChatRoomRenameChatRoomResponse { +return CChatRoomRenameChatRoomResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomrenamechatroomresponse(o CChatRoomRenameChatRoomResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomrenamechatroomresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomRenameChatRoomResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomrenamechatroomresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomReorderChatRoomRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +chat_id u64 +has_chat_id bool +move_after_chat_id u64 +has_move_after_chat_id bool +} +pub fn (o &CChatRoomReorderChatRoomRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_chat_id { +res << vproto.pack_uint64_field(o.chat_id, 2) +} + +if o.has_move_after_chat_id { +res << vproto.pack_uint64_field(o.move_after_chat_id, 3) +} + +return res +} + +pub fn cchatroomreorderchatroomrequest_unpack(buf []byte) ?CChatRoomReorderChatRoomRequest { +mut res := CChatRoomReorderChatRoomRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +3 { +res.has_move_after_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.move_after_chat_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomreorderchatroomrequest() CChatRoomReorderChatRoomRequest { +return CChatRoomReorderChatRoomRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomreorderchatroomrequest(o CChatRoomReorderChatRoomRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomreorderchatroomrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomReorderChatRoomRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomreorderchatroomrequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomReorderChatRoomResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CChatRoomReorderChatRoomResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cchatroomreorderchatroomresponse_unpack(buf []byte) ?CChatRoomReorderChatRoomResponse { +res := CChatRoomReorderChatRoomResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomreorderchatroomresponse() CChatRoomReorderChatRoomResponse { +return CChatRoomReorderChatRoomResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomreorderchatroomresponse(o CChatRoomReorderChatRoomResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomreorderchatroomresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomReorderChatRoomResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomreorderchatroomresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomSendChatMessageRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +chat_id u64 +has_chat_id bool +message string +has_message bool +echo_to_sender bool +has_echo_to_sender bool +} +pub fn (o &CChatRoomSendChatMessageRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_chat_id { +res << vproto.pack_uint64_field(o.chat_id, 2) +} + +if o.has_message { +res << vproto.pack_string_field(o.message, 3) +} + +if o.has_echo_to_sender { +res << vproto.pack_bool_field(o.echo_to_sender, 4) +} + +return res +} + +pub fn cchatroomsendchatmessagerequest_unpack(buf []byte) ?CChatRoomSendChatMessageRequest { +mut res := CChatRoomSendChatMessageRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +3 { +res.has_message = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.message = v +i = ii +} + +4 { +res.has_echo_to_sender = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.echo_to_sender = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomsendchatmessagerequest() CChatRoomSendChatMessageRequest { +return CChatRoomSendChatMessageRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomsendchatmessagerequest(o CChatRoomSendChatMessageRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomsendchatmessagerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomSendChatMessageRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomsendchatmessagerequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomSendChatMessageResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +modified_message string +has_modified_message bool +server_timestamp u32 +has_server_timestamp bool +ordinal u32 +has_ordinal bool +message_without_bb_code string +has_message_without_bb_code bool +} +pub fn (o &CChatRoomSendChatMessageResponse) pack() []byte { +mut res := []byte{} +if o.has_modified_message { +res << vproto.pack_string_field(o.modified_message, 1) +} + +if o.has_server_timestamp { +res << vproto.pack_uint32_field(o.server_timestamp, 2) +} + +if o.has_ordinal { +res << vproto.pack_uint32_field(o.ordinal, 3) +} + +if o.has_message_without_bb_code { +res << vproto.pack_string_field(o.message_without_bb_code, 4) +} + +return res +} + +pub fn cchatroomsendchatmessageresponse_unpack(buf []byte) ?CChatRoomSendChatMessageResponse { +mut res := CChatRoomSendChatMessageResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_modified_message = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.modified_message = v +i = ii +} + +2 { +res.has_server_timestamp = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.server_timestamp = v +i = ii +} + +3 { +res.has_ordinal = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ordinal = v +i = ii +} + +4 { +res.has_message_without_bb_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.message_without_bb_code = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomsendchatmessageresponse() CChatRoomSendChatMessageResponse { +return CChatRoomSendChatMessageResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomsendchatmessageresponse(o CChatRoomSendChatMessageResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomsendchatmessageresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomSendChatMessageResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomsendchatmessageresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomJoinVoiceChatRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +chat_id u64 +has_chat_id bool +} +pub fn (o &CChatRoomJoinVoiceChatRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_chat_id { +res << vproto.pack_uint64_field(o.chat_id, 2) +} + +return res +} + +pub fn cchatroomjoinvoicechatrequest_unpack(buf []byte) ?CChatRoomJoinVoiceChatRequest { +mut res := CChatRoomJoinVoiceChatRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomjoinvoicechatrequest() CChatRoomJoinVoiceChatRequest { +return CChatRoomJoinVoiceChatRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomjoinvoicechatrequest(o CChatRoomJoinVoiceChatRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomjoinvoicechatrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomJoinVoiceChatRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomjoinvoicechatrequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomJoinVoiceChatResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +voice_chatid u64 +has_voice_chatid bool +} +pub fn (o &CChatRoomJoinVoiceChatResponse) pack() []byte { +mut res := []byte{} +if o.has_voice_chatid { +res << vproto.pack_uint64_field(o.voice_chatid, 1) +} + +return res +} + +pub fn cchatroomjoinvoicechatresponse_unpack(buf []byte) ?CChatRoomJoinVoiceChatResponse { +mut res := CChatRoomJoinVoiceChatResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_voice_chatid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.voice_chatid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomjoinvoicechatresponse() CChatRoomJoinVoiceChatResponse { +return CChatRoomJoinVoiceChatResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomjoinvoicechatresponse(o CChatRoomJoinVoiceChatResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomjoinvoicechatresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomJoinVoiceChatResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomjoinvoicechatresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomLeaveVoiceChatRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +chat_id u64 +has_chat_id bool +} +pub fn (o &CChatRoomLeaveVoiceChatRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_chat_id { +res << vproto.pack_uint64_field(o.chat_id, 2) +} + +return res +} + +pub fn cchatroomleavevoicechatrequest_unpack(buf []byte) ?CChatRoomLeaveVoiceChatRequest { +mut res := CChatRoomLeaveVoiceChatRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomleavevoicechatrequest() CChatRoomLeaveVoiceChatRequest { +return CChatRoomLeaveVoiceChatRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomleavevoicechatrequest(o CChatRoomLeaveVoiceChatRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomleavevoicechatrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomLeaveVoiceChatRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomleavevoicechatrequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomLeaveVoiceChatResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CChatRoomLeaveVoiceChatResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cchatroomleavevoicechatresponse_unpack(buf []byte) ?CChatRoomLeaveVoiceChatResponse { +res := CChatRoomLeaveVoiceChatResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomleavevoicechatresponse() CChatRoomLeaveVoiceChatResponse { +return CChatRoomLeaveVoiceChatResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomleavevoicechatresponse(o CChatRoomLeaveVoiceChatResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomleavevoicechatresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomLeaveVoiceChatResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomleavevoicechatresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGetMessageHistoryRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +chat_id u64 +has_chat_id bool +last_time u32 +has_last_time bool +last_ordinal u32 +has_last_ordinal bool +start_time u32 +has_start_time bool +start_ordinal u32 +has_start_ordinal bool +max_count u32 +has_max_count bool +} +pub fn (o &CChatRoomGetMessageHistoryRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_chat_id { +res << vproto.pack_uint64_field(o.chat_id, 2) +} + +if o.has_last_time { +res << vproto.pack_uint32_field(o.last_time, 3) +} + +if o.has_last_ordinal { +res << vproto.pack_uint32_field(o.last_ordinal, 4) +} + +if o.has_start_time { +res << vproto.pack_uint32_field(o.start_time, 5) +} + +if o.has_start_ordinal { +res << vproto.pack_uint32_field(o.start_ordinal, 6) +} + +if o.has_max_count { +res << vproto.pack_uint32_field(o.max_count, 7) +} + +return res +} + +pub fn cchatroomgetmessagehistoryrequest_unpack(buf []byte) ?CChatRoomGetMessageHistoryRequest { +mut res := CChatRoomGetMessageHistoryRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +3 { +res.has_last_time = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_time = v +i = ii +} + +4 { +res.has_last_ordinal = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_ordinal = v +i = ii +} + +5 { +res.has_start_time = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.start_time = v +i = ii +} + +6 { +res.has_start_ordinal = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.start_ordinal = v +i = ii +} + +7 { +res.has_max_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.max_count = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgetmessagehistoryrequest() CChatRoomGetMessageHistoryRequest { +return CChatRoomGetMessageHistoryRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgetmessagehistoryrequest(o CChatRoomGetMessageHistoryRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgetmessagehistoryrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGetMessageHistoryRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgetmessagehistoryrequest_unpack(v)? +return i, unpacked +} +pub struct ServerMessage { +mut: +unknown_fields []vproto.UnknownField +pub mut: +message EChatRoomServerMessage +has_message bool +string_param string +has_string_param bool +accountid_param u32 +has_accountid_param bool +} +pub fn (o &ServerMessage) pack() []byte { +mut res := []byte{} +if o.has_message { +res << zzz_vproto_internal_pack_echatroomservermessage(o.message, 1) +} + +if o.has_string_param { +res << vproto.pack_string_field(o.string_param, 2) +} + +if o.has_accountid_param { +res << vproto.pack_uint32_field(o.accountid_param, 3) +} + +return res +} + +pub fn servermessage_unpack(buf []byte) ?ServerMessage { +mut res := ServerMessage{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_message = true +ii, v := zzz_vproto_internal_unpack_echatroomservermessage(cur_buf, tag_wiretype.wire_type)? +res.message = v +i = ii +} + +2 { +res.has_string_param = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.string_param = v +i = ii +} + +3 { +res.has_accountid_param = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.accountid_param = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_servermessage() ServerMessage { +return ServerMessage{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_servermessage(o ServerMessage, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_servermessage(buf []byte, tag_wiretype vproto.WireType) ?(int, ServerMessage) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := servermessage_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGetMessageHistoryResponseChatMessage { +mut: +unknown_fields []vproto.UnknownField +pub mut: +sender u32 +has_sender bool +server_timestamp u32 +has_server_timestamp bool +message string +has_message bool +ordinal u32 +has_ordinal bool +server_message ServerMessage +has_server_message bool +deleted bool +has_deleted bool +} +pub fn (o &CChatRoomGetMessageHistoryResponseChatMessage) pack() []byte { +mut res := []byte{} +if o.has_sender { +res << vproto.pack_uint32_field(o.sender, 1) +} + +if o.has_server_timestamp { +res << vproto.pack_uint32_field(o.server_timestamp, 2) +} + +if o.has_message { +res << vproto.pack_string_field(o.message, 3) +} + +if o.has_ordinal { +res << vproto.pack_uint32_field(o.ordinal, 4) +} + +if o.has_server_message { +res << zzz_vproto_internal_pack_servermessage(o.server_message, 5) +} + +if o.has_deleted { +res << vproto.pack_bool_field(o.deleted, 6) +} + +return res +} + +pub fn cchatroomgetmessagehistoryresponsechatmessage_unpack(buf []byte) ?CChatRoomGetMessageHistoryResponseChatMessage { +mut res := CChatRoomGetMessageHistoryResponseChatMessage{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_sender = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.sender = v +i = ii +} + +2 { +res.has_server_timestamp = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.server_timestamp = v +i = ii +} + +3 { +res.has_message = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.message = v +i = ii +} + +4 { +res.has_ordinal = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ordinal = v +i = ii +} + +5 { +res.has_server_message = true +ii, v := zzz_vproto_internal_unpack_servermessage(cur_buf, tag_wiretype.wire_type)? +res.server_message = v +i = ii +} + +6 { +res.has_deleted = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.deleted = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgetmessagehistoryresponsechatmessage() CChatRoomGetMessageHistoryResponseChatMessage { +return CChatRoomGetMessageHistoryResponseChatMessage{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgetmessagehistoryresponsechatmessage(o CChatRoomGetMessageHistoryResponseChatMessage, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgetmessagehistoryresponsechatmessage(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGetMessageHistoryResponseChatMessage) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgetmessagehistoryresponsechatmessage_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGetMessageHistoryResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +messages []CChatRoomGetMessageHistoryResponseChatMessage +more_available bool +has_more_available bool +} +pub fn (o &CChatRoomGetMessageHistoryResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.messages { +res << zzz_vproto_internal_pack_cchatroomgetmessagehistoryresponsechatmessage(x, 1) +} + +if o.has_more_available { +res << vproto.pack_bool_field(o.more_available, 4) +} + +return res +} + +pub fn cchatroomgetmessagehistoryresponse_unpack(buf []byte) ?CChatRoomGetMessageHistoryResponse { +mut res := CChatRoomGetMessageHistoryResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cchatroomgetmessagehistoryresponsechatmessage(cur_buf, tag_wiretype.wire_type)? +res.messages << v +i = ii +} + +4 { +res.has_more_available = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.more_available = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgetmessagehistoryresponse() CChatRoomGetMessageHistoryResponse { +return CChatRoomGetMessageHistoryResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgetmessagehistoryresponse(o CChatRoomGetMessageHistoryResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgetmessagehistoryresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGetMessageHistoryResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgetmessagehistoryresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGetMyChatRoomGroupsRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CChatRoomGetMyChatRoomGroupsRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn cchatroomgetmychatroomgroupsrequest_unpack(buf []byte) ?CChatRoomGetMyChatRoomGroupsRequest { +res := CChatRoomGetMyChatRoomGroupsRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgetmychatroomgroupsrequest() CChatRoomGetMyChatRoomGroupsRequest { +return CChatRoomGetMyChatRoomGroupsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgetmychatroomgroupsrequest(o CChatRoomGetMyChatRoomGroupsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgetmychatroomgroupsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGetMyChatRoomGroupsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgetmychatroomgroupsrequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGetChatRoomGroupSummaryResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +chat_group_name string +has_chat_group_name bool +active_member_count u32 +has_active_member_count bool +active_voice_member_count u32 +has_active_voice_member_count bool +default_chat_id u64 +has_default_chat_id bool +chat_rooms []CChatRoomState +clanid u32 +has_clanid bool +chat_group_tagline string +has_chat_group_tagline bool +accountid_owner u32 +has_accountid_owner bool +top_members []u32 +chat_group_avatar_sha []byte +has_chat_group_avatar_sha bool +rank EChatRoomGroupRank +has_rank bool +default_role_id u64 +has_default_role_id bool +role_ids []u64 +role_actions []CChatRoleActions +watching_broadcast_accountid u32 +has_watching_broadcast_accountid bool +appid u32 +has_appid bool +party_beacons []CChatPartyBeacon +watching_broadcast_channel_id u64 +has_watching_broadcast_channel_id bool +active_minigame_id u64 +has_active_minigame_id bool +avatar_ugc_url string +has_avatar_ugc_url bool +} +pub fn (o &CChatRoomGetChatRoomGroupSummaryResponse) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_chat_group_name { +res << vproto.pack_string_field(o.chat_group_name, 2) +} + +if o.has_active_member_count { +res << vproto.pack_uint32_field(o.active_member_count, 3) +} + +if o.has_active_voice_member_count { +res << vproto.pack_uint32_field(o.active_voice_member_count, 4) +} + +if o.has_default_chat_id { +res << vproto.pack_uint64_field(o.default_chat_id, 5) +} + +// [packed=false] +for _, x in o.chat_rooms { +res << zzz_vproto_internal_pack_cchatroomstate(x, 6) +} + +if o.has_clanid { +res << vproto.pack_uint32_field(o.clanid, 7) +} + +if o.has_chat_group_tagline { +res << vproto.pack_string_field(o.chat_group_tagline, 8) +} + +if o.has_accountid_owner { +res << vproto.pack_uint32_field(o.accountid_owner, 9) +} + +// [packed=false] +for _, x in o.top_members { +res << vproto.pack_uint32_field(x, 10) +} + +if o.has_chat_group_avatar_sha { +res << vproto.pack_bytes_field(o.chat_group_avatar_sha, 11) +} + +if o.has_rank { +res << zzz_vproto_internal_pack_echatroomgrouprank(o.rank, 12) +} + +if o.has_default_role_id { +res << vproto.pack_uint64_field(o.default_role_id, 13) +} + +// [packed=false] +for _, x in o.role_ids { +res << vproto.pack_uint64_field(x, 14) +} + +// [packed=false] +for _, x in o.role_actions { +res << zzz_vproto_internal_pack_cchatroleactions(x, 15) +} + +if o.has_watching_broadcast_accountid { +res << vproto.pack_uint32_field(o.watching_broadcast_accountid, 16) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 17) +} + +// [packed=false] +for _, x in o.party_beacons { +res << zzz_vproto_internal_pack_cchatpartybeacon(x, 18) +} + +if o.has_watching_broadcast_channel_id { +res << vproto.pack_uint64_field(o.watching_broadcast_channel_id, 19) +} + +if o.has_active_minigame_id { +res << vproto.pack_uint64_field(o.active_minigame_id, 20) +} + +if o.has_avatar_ugc_url { +res << vproto.pack_string_field(o.avatar_ugc_url, 21) +} + +return res +} + +pub fn cchatroomgetchatroomgroupsummaryresponse_unpack(buf []byte) ?CChatRoomGetChatRoomGroupSummaryResponse { +mut res := CChatRoomGetChatRoomGroupSummaryResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_chat_group_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_name = v +i = ii +} + +3 { +res.has_active_member_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.active_member_count = v +i = ii +} + +4 { +res.has_active_voice_member_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.active_voice_member_count = v +i = ii +} + +5 { +res.has_default_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.default_chat_id = v +i = ii +} + +6 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cchatroomstate(cur_buf, tag_wiretype.wire_type)? +res.chat_rooms << v +i = ii +} + +7 { +res.has_clanid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.clanid = v +i = ii +} + +8 { +res.has_chat_group_tagline = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_tagline = v +i = ii +} + +9 { +res.has_accountid_owner = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.accountid_owner = v +i = ii +} + +10 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.top_members << v +i = ii +} + +11 { +res.has_chat_group_avatar_sha = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_avatar_sha = v +i = ii +} + +12 { +res.has_rank = true +ii, v := zzz_vproto_internal_unpack_echatroomgrouprank(cur_buf, tag_wiretype.wire_type)? +res.rank = v +i = ii +} + +13 { +res.has_default_role_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.default_role_id = v +i = ii +} + +14 { +// [packed=false] +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.role_ids << v +i = ii +} + +15 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cchatroleactions(cur_buf, tag_wiretype.wire_type)? +res.role_actions << v +i = ii +} + +16 { +res.has_watching_broadcast_accountid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.watching_broadcast_accountid = v +i = ii +} + +17 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +18 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cchatpartybeacon(cur_buf, tag_wiretype.wire_type)? +res.party_beacons << v +i = ii +} + +19 { +res.has_watching_broadcast_channel_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.watching_broadcast_channel_id = v +i = ii +} + +20 { +res.has_active_minigame_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.active_minigame_id = v +i = ii +} + +21 { +res.has_avatar_ugc_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.avatar_ugc_url = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgetchatroomgroupsummaryresponse() CChatRoomGetChatRoomGroupSummaryResponse { +return CChatRoomGetChatRoomGroupSummaryResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgetchatroomgroupsummaryresponse(o CChatRoomGetChatRoomGroupSummaryResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgetchatroomgroupsummaryresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGetChatRoomGroupSummaryResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgetchatroomgroupsummaryresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomSummaryPair { +mut: +unknown_fields []vproto.UnknownField +pub mut: +user_chat_group_state CUserChatRoomGroupState +has_user_chat_group_state bool +group_summary CChatRoomGetChatRoomGroupSummaryResponse +has_group_summary bool +} +pub fn (o &CChatRoomSummaryPair) pack() []byte { +mut res := []byte{} +if o.has_user_chat_group_state { +res << zzz_vproto_internal_pack_cuserchatroomgroupstate(o.user_chat_group_state, 1) +} + +if o.has_group_summary { +res << zzz_vproto_internal_pack_cchatroomgetchatroomgroupsummaryresponse(o.group_summary, 2) +} + +return res +} + +pub fn cchatroomsummarypair_unpack(buf []byte) ?CChatRoomSummaryPair { +mut res := CChatRoomSummaryPair{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_user_chat_group_state = true +ii, v := zzz_vproto_internal_unpack_cuserchatroomgroupstate(cur_buf, tag_wiretype.wire_type)? +res.user_chat_group_state = v +i = ii +} + +2 { +res.has_group_summary = true +ii, v := zzz_vproto_internal_unpack_cchatroomgetchatroomgroupsummaryresponse(cur_buf, tag_wiretype.wire_type)? +res.group_summary = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomsummarypair() CChatRoomSummaryPair { +return CChatRoomSummaryPair{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomsummarypair(o CChatRoomSummaryPair, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomsummarypair(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomSummaryPair) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomsummarypair_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGetMyChatRoomGroupsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_room_groups []CChatRoomSummaryPair +} +pub fn (o &CChatRoomGetMyChatRoomGroupsResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.chat_room_groups { +res << zzz_vproto_internal_pack_cchatroomsummarypair(x, 1) +} + +return res +} + +pub fn cchatroomgetmychatroomgroupsresponse_unpack(buf []byte) ?CChatRoomGetMyChatRoomGroupsResponse { +mut res := CChatRoomGetMyChatRoomGroupsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cchatroomsummarypair(cur_buf, tag_wiretype.wire_type)? +res.chat_room_groups << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgetmychatroomgroupsresponse() CChatRoomGetMyChatRoomGroupsResponse { +return CChatRoomGetMyChatRoomGroupsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgetmychatroomgroupsresponse(o CChatRoomGetMyChatRoomGroupsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgetmychatroomgroupsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGetMyChatRoomGroupsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgetmychatroomgroupsresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGetChatRoomGroupStateRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +} +pub fn (o &CChatRoomGetChatRoomGroupStateRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +return res +} + +pub fn cchatroomgetchatroomgroupstaterequest_unpack(buf []byte) ?CChatRoomGetChatRoomGroupStateRequest { +mut res := CChatRoomGetChatRoomGroupStateRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgetchatroomgroupstaterequest() CChatRoomGetChatRoomGroupStateRequest { +return CChatRoomGetChatRoomGroupStateRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgetchatroomgroupstaterequest(o CChatRoomGetChatRoomGroupStateRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgetchatroomgroupstaterequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGetChatRoomGroupStateRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgetchatroomgroupstaterequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGetChatRoomGroupStateResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +state CChatRoomGroupState +has_state bool +} +pub fn (o &CChatRoomGetChatRoomGroupStateResponse) pack() []byte { +mut res := []byte{} +if o.has_state { +res << zzz_vproto_internal_pack_cchatroomgroupstate(o.state, 1) +} + +return res +} + +pub fn cchatroomgetchatroomgroupstateresponse_unpack(buf []byte) ?CChatRoomGetChatRoomGroupStateResponse { +mut res := CChatRoomGetChatRoomGroupStateResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_state = true +ii, v := zzz_vproto_internal_unpack_cchatroomgroupstate(cur_buf, tag_wiretype.wire_type)? +res.state = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgetchatroomgroupstateresponse() CChatRoomGetChatRoomGroupStateResponse { +return CChatRoomGetChatRoomGroupStateResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgetchatroomgroupstateresponse(o CChatRoomGetChatRoomGroupStateResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgetchatroomgroupstateresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGetChatRoomGroupStateResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgetchatroomgroupstateresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGetChatRoomGroupSummaryRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +} +pub fn (o &CChatRoomGetChatRoomGroupSummaryRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +return res +} + +pub fn cchatroomgetchatroomgroupsummaryrequest_unpack(buf []byte) ?CChatRoomGetChatRoomGroupSummaryRequest { +mut res := CChatRoomGetChatRoomGroupSummaryRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgetchatroomgroupsummaryrequest() CChatRoomGetChatRoomGroupSummaryRequest { +return CChatRoomGetChatRoomGroupSummaryRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgetchatroomgroupsummaryrequest(o CChatRoomGetChatRoomGroupSummaryRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgetchatroomgroupsummaryrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGetChatRoomGroupSummaryRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgetchatroomgroupsummaryrequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomSetAppChatRoomGroupForceActiveRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +requesting_app_id u32 +has_requesting_app_id bool +} +pub fn (o &CChatRoomSetAppChatRoomGroupForceActiveRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_requesting_app_id { +res << vproto.pack_uint32_field(o.requesting_app_id, 2) +} + +return res +} + +pub fn cchatroomsetappchatroomgroupforceactiverequest_unpack(buf []byte) ?CChatRoomSetAppChatRoomGroupForceActiveRequest { +mut res := CChatRoomSetAppChatRoomGroupForceActiveRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_requesting_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.requesting_app_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomsetappchatroomgroupforceactiverequest() CChatRoomSetAppChatRoomGroupForceActiveRequest { +return CChatRoomSetAppChatRoomGroupForceActiveRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomsetappchatroomgroupforceactiverequest(o CChatRoomSetAppChatRoomGroupForceActiveRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomsetappchatroomgroupforceactiverequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomSetAppChatRoomGroupForceActiveRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomsetappchatroomgroupforceactiverequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomSetAppChatRoomGroupForceActiveResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +result u32 +has_result bool +accounts_in_channel []u32 +} +pub fn (o &CChatRoomSetAppChatRoomGroupForceActiveResponse) pack() []byte { +mut res := []byte{} +if o.has_result { +res << vproto.pack_uint32_field(o.result, 1) +} + +// [packed=false] +for _, x in o.accounts_in_channel { +res << vproto.pack_uint32_field(x, 2) +} + +return res +} + +pub fn cchatroomsetappchatroomgroupforceactiveresponse_unpack(buf []byte) ?CChatRoomSetAppChatRoomGroupForceActiveResponse { +mut res := CChatRoomSetAppChatRoomGroupForceActiveResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_result = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.result = v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.accounts_in_channel << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomsetappchatroomgroupforceactiveresponse() CChatRoomSetAppChatRoomGroupForceActiveResponse { +return CChatRoomSetAppChatRoomGroupForceActiveResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomsetappchatroomgroupforceactiveresponse(o CChatRoomSetAppChatRoomGroupForceActiveResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomsetappchatroomgroupforceactiveresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomSetAppChatRoomGroupForceActiveResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomsetappchatroomgroupforceactiveresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomSetAppChatRoomGroupStopForceActiveNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +requesting_app_id u32 +has_requesting_app_id bool +} +pub fn (o &CChatRoomSetAppChatRoomGroupStopForceActiveNotification) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_requesting_app_id { +res << vproto.pack_uint32_field(o.requesting_app_id, 2) +} + +return res +} + +pub fn cchatroomsetappchatroomgroupstopforceactivenotification_unpack(buf []byte) ?CChatRoomSetAppChatRoomGroupStopForceActiveNotification { +mut res := CChatRoomSetAppChatRoomGroupStopForceActiveNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_requesting_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.requesting_app_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomsetappchatroomgroupstopforceactivenotification() CChatRoomSetAppChatRoomGroupStopForceActiveNotification { +return CChatRoomSetAppChatRoomGroupStopForceActiveNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomsetappchatroomgroupstopforceactivenotification(o CChatRoomSetAppChatRoomGroupStopForceActiveNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomsetappchatroomgroupstopforceactivenotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomSetAppChatRoomGroupStopForceActiveNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomsetappchatroomgroupstopforceactivenotification_unpack(v)? +return i, unpacked +} +pub struct CChatRoomAckChatMessageNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +chat_id u64 +has_chat_id bool +timestamp u32 +has_timestamp bool +} +pub fn (o &CChatRoomAckChatMessageNotification) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_chat_id { +res << vproto.pack_uint64_field(o.chat_id, 2) +} + +if o.has_timestamp { +res << vproto.pack_uint32_field(o.timestamp, 3) +} + +return res +} + +pub fn cchatroomackchatmessagenotification_unpack(buf []byte) ?CChatRoomAckChatMessageNotification { +mut res := CChatRoomAckChatMessageNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +3 { +res.has_timestamp = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomackchatmessagenotification() CChatRoomAckChatMessageNotification { +return CChatRoomAckChatMessageNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomackchatmessagenotification(o CChatRoomAckChatMessageNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomackchatmessagenotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomAckChatMessageNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomackchatmessagenotification_unpack(v)? +return i, unpacked +} +pub struct CChatRoomCreateInviteLinkRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +seconds_valid u32 +has_seconds_valid bool +chat_id u64 +has_chat_id bool +} +pub fn (o &CChatRoomCreateInviteLinkRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_seconds_valid { +res << vproto.pack_uint32_field(o.seconds_valid, 2) +} + +if o.has_chat_id { +res << vproto.pack_uint64_field(o.chat_id, 3) +} + +return res +} + +pub fn cchatroomcreateinvitelinkrequest_unpack(buf []byte) ?CChatRoomCreateInviteLinkRequest { +mut res := CChatRoomCreateInviteLinkRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_seconds_valid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_valid = v +i = ii +} + +3 { +res.has_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomcreateinvitelinkrequest() CChatRoomCreateInviteLinkRequest { +return CChatRoomCreateInviteLinkRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomcreateinvitelinkrequest(o CChatRoomCreateInviteLinkRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomcreateinvitelinkrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomCreateInviteLinkRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomcreateinvitelinkrequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomCreateInviteLinkResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +invite_code string +has_invite_code bool +seconds_valid u32 +has_seconds_valid bool +} +pub fn (o &CChatRoomCreateInviteLinkResponse) pack() []byte { +mut res := []byte{} +if o.has_invite_code { +res << vproto.pack_string_field(o.invite_code, 1) +} + +if o.has_seconds_valid { +res << vproto.pack_uint32_field(o.seconds_valid, 2) +} + +return res +} + +pub fn cchatroomcreateinvitelinkresponse_unpack(buf []byte) ?CChatRoomCreateInviteLinkResponse { +mut res := CChatRoomCreateInviteLinkResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_invite_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.invite_code = v +i = ii +} + +2 { +res.has_seconds_valid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_valid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomcreateinvitelinkresponse() CChatRoomCreateInviteLinkResponse { +return CChatRoomCreateInviteLinkResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomcreateinvitelinkresponse(o CChatRoomCreateInviteLinkResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomcreateinvitelinkresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomCreateInviteLinkResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomcreateinvitelinkresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGetInviteLinkInfoRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +invite_code string +has_invite_code bool +} +pub fn (o &CChatRoomGetInviteLinkInfoRequest) pack() []byte { +mut res := []byte{} +if o.has_invite_code { +res << vproto.pack_string_field(o.invite_code, 1) +} + +return res +} + +pub fn cchatroomgetinvitelinkinforequest_unpack(buf []byte) ?CChatRoomGetInviteLinkInfoRequest { +mut res := CChatRoomGetInviteLinkInfoRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_invite_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.invite_code = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgetinvitelinkinforequest() CChatRoomGetInviteLinkInfoRequest { +return CChatRoomGetInviteLinkInfoRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgetinvitelinkinforequest(o CChatRoomGetInviteLinkInfoRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgetinvitelinkinforequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGetInviteLinkInfoRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgetinvitelinkinforequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGetInviteLinkInfoResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid_sender u64 +has_steamid_sender bool +time_expires u32 +has_time_expires bool +chat_id u64 +has_chat_id bool +group_summary CChatRoomGetChatRoomGroupSummaryResponse +has_group_summary bool +user_chat_group_state CUserChatRoomGroupState +has_user_chat_group_state bool +time_kick_expire u32 +has_time_kick_expire bool +banned bool +has_banned bool +} +pub fn (o &CChatRoomGetInviteLinkInfoResponse) pack() []byte { +mut res := []byte{} +if o.has_steamid_sender { +res << vproto.pack_64bit_field(o.steamid_sender, 3) +} + +if o.has_time_expires { +res << vproto.pack_uint32_field(o.time_expires, 4) +} + +if o.has_chat_id { +res << vproto.pack_uint64_field(o.chat_id, 6) +} + +if o.has_group_summary { +res << zzz_vproto_internal_pack_cchatroomgetchatroomgroupsummaryresponse(o.group_summary, 8) +} + +if o.has_user_chat_group_state { +res << zzz_vproto_internal_pack_cuserchatroomgroupstate(o.user_chat_group_state, 9) +} + +if o.has_time_kick_expire { +res << vproto.pack_uint32_field(o.time_kick_expire, 10) +} + +if o.has_banned { +res << vproto.pack_bool_field(o.banned, 11) +} + +return res +} + +pub fn cchatroomgetinvitelinkinforesponse_unpack(buf []byte) ?CChatRoomGetInviteLinkInfoResponse { +mut res := CChatRoomGetInviteLinkInfoResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +3 { +res.has_steamid_sender = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_sender = v +i = ii +} + +4 { +res.has_time_expires = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_expires = v +i = ii +} + +6 { +res.has_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +8 { +res.has_group_summary = true +ii, v := zzz_vproto_internal_unpack_cchatroomgetchatroomgroupsummaryresponse(cur_buf, tag_wiretype.wire_type)? +res.group_summary = v +i = ii +} + +9 { +res.has_user_chat_group_state = true +ii, v := zzz_vproto_internal_unpack_cuserchatroomgroupstate(cur_buf, tag_wiretype.wire_type)? +res.user_chat_group_state = v +i = ii +} + +10 { +res.has_time_kick_expire = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_kick_expire = v +i = ii +} + +11 { +res.has_banned = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.banned = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgetinvitelinkinforesponse() CChatRoomGetInviteLinkInfoResponse { +return CChatRoomGetInviteLinkInfoResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgetinvitelinkinforesponse(o CChatRoomGetInviteLinkInfoResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgetinvitelinkinforesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGetInviteLinkInfoResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgetinvitelinkinforesponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGetInviteInfoRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid_invitee u64 +has_steamid_invitee bool +chat_group_id u64 +has_chat_group_id bool +chat_id u64 +has_chat_id bool +invite_code string +has_invite_code bool +} +pub fn (o &CChatRoomGetInviteInfoRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid_invitee { +res << vproto.pack_64bit_field(o.steamid_invitee, 1) +} + +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 2) +} + +if o.has_chat_id { +res << vproto.pack_uint64_field(o.chat_id, 3) +} + +if o.has_invite_code { +res << vproto.pack_string_field(o.invite_code, 4) +} + +return res +} + +pub fn cchatroomgetinviteinforequest_unpack(buf []byte) ?CChatRoomGetInviteInfoRequest { +mut res := CChatRoomGetInviteInfoRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid_invitee = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_invitee = v +i = ii +} + +2 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +3 { +res.has_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +4 { +res.has_invite_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.invite_code = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgetinviteinforequest() CChatRoomGetInviteInfoRequest { +return CChatRoomGetInviteInfoRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgetinviteinforequest(o CChatRoomGetInviteInfoRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgetinviteinforequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGetInviteInfoRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgetinviteinforequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGetInviteInfoResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +group_summary CChatRoomGetChatRoomGroupSummaryResponse +has_group_summary bool +time_kick_expire u32 +has_time_kick_expire bool +banned bool +has_banned bool +} +pub fn (o &CChatRoomGetInviteInfoResponse) pack() []byte { +mut res := []byte{} +if o.has_group_summary { +res << zzz_vproto_internal_pack_cchatroomgetchatroomgroupsummaryresponse(o.group_summary, 1) +} + +if o.has_time_kick_expire { +res << vproto.pack_uint32_field(o.time_kick_expire, 2) +} + +if o.has_banned { +res << vproto.pack_bool_field(o.banned, 3) +} + +return res +} + +pub fn cchatroomgetinviteinforesponse_unpack(buf []byte) ?CChatRoomGetInviteInfoResponse { +mut res := CChatRoomGetInviteInfoResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_group_summary = true +ii, v := zzz_vproto_internal_unpack_cchatroomgetchatroomgroupsummaryresponse(cur_buf, tag_wiretype.wire_type)? +res.group_summary = v +i = ii +} + +2 { +res.has_time_kick_expire = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_kick_expire = v +i = ii +} + +3 { +res.has_banned = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.banned = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgetinviteinforesponse() CChatRoomGetInviteInfoResponse { +return CChatRoomGetInviteInfoResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgetinviteinforesponse(o CChatRoomGetInviteInfoResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgetinviteinforesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGetInviteInfoResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgetinviteinforesponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGetInviteLinksForGroupRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +} +pub fn (o &CChatRoomGetInviteLinksForGroupRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +return res +} + +pub fn cchatroomgetinvitelinksforgrouprequest_unpack(buf []byte) ?CChatRoomGetInviteLinksForGroupRequest { +mut res := CChatRoomGetInviteLinksForGroupRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgetinvitelinksforgrouprequest() CChatRoomGetInviteLinksForGroupRequest { +return CChatRoomGetInviteLinksForGroupRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgetinvitelinksforgrouprequest(o CChatRoomGetInviteLinksForGroupRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgetinvitelinksforgrouprequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGetInviteLinksForGroupRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgetinvitelinksforgrouprequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGetInviteLinksForGroupResponseLinkInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +invite_code string +has_invite_code bool +steamid_creator u64 +has_steamid_creator bool +time_expires u32 +has_time_expires bool +chat_id u64 +has_chat_id bool +} +pub fn (o &CChatRoomGetInviteLinksForGroupResponseLinkInfo) pack() []byte { +mut res := []byte{} +if o.has_invite_code { +res << vproto.pack_string_field(o.invite_code, 1) +} + +if o.has_steamid_creator { +res << vproto.pack_64bit_field(o.steamid_creator, 2) +} + +if o.has_time_expires { +res << vproto.pack_uint32_field(o.time_expires, 3) +} + +if o.has_chat_id { +res << vproto.pack_uint64_field(o.chat_id, 4) +} + +return res +} + +pub fn cchatroomgetinvitelinksforgroupresponselinkinfo_unpack(buf []byte) ?CChatRoomGetInviteLinksForGroupResponseLinkInfo { +mut res := CChatRoomGetInviteLinksForGroupResponseLinkInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_invite_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.invite_code = v +i = ii +} + +2 { +res.has_steamid_creator = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_creator = v +i = ii +} + +3 { +res.has_time_expires = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_expires = v +i = ii +} + +4 { +res.has_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgetinvitelinksforgroupresponselinkinfo() CChatRoomGetInviteLinksForGroupResponseLinkInfo { +return CChatRoomGetInviteLinksForGroupResponseLinkInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgetinvitelinksforgroupresponselinkinfo(o CChatRoomGetInviteLinksForGroupResponseLinkInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgetinvitelinksforgroupresponselinkinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGetInviteLinksForGroupResponseLinkInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgetinvitelinksforgroupresponselinkinfo_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGetInviteLinksForGroupResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +invite_links []CChatRoomGetInviteLinksForGroupResponseLinkInfo +} +pub fn (o &CChatRoomGetInviteLinksForGroupResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.invite_links { +res << zzz_vproto_internal_pack_cchatroomgetinvitelinksforgroupresponselinkinfo(x, 1) +} + +return res +} + +pub fn cchatroomgetinvitelinksforgroupresponse_unpack(buf []byte) ?CChatRoomGetInviteLinksForGroupResponse { +mut res := CChatRoomGetInviteLinksForGroupResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cchatroomgetinvitelinksforgroupresponselinkinfo(cur_buf, tag_wiretype.wire_type)? +res.invite_links << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgetinvitelinksforgroupresponse() CChatRoomGetInviteLinksForGroupResponse { +return CChatRoomGetInviteLinksForGroupResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgetinvitelinksforgroupresponse(o CChatRoomGetInviteLinksForGroupResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgetinvitelinksforgroupresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGetInviteLinksForGroupResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgetinvitelinksforgroupresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGetBanListRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +} +pub fn (o &CChatRoomGetBanListRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +return res +} + +pub fn cchatroomgetbanlistrequest_unpack(buf []byte) ?CChatRoomGetBanListRequest { +mut res := CChatRoomGetBanListRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgetbanlistrequest() CChatRoomGetBanListRequest { +return CChatRoomGetBanListRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgetbanlistrequest(o CChatRoomGetBanListRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgetbanlistrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGetBanListRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgetbanlistrequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGetBanListResponseBanInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +accountid u32 +has_accountid bool +accountid_actor u32 +has_accountid_actor bool +time_banned u32 +has_time_banned bool +ban_reason string +has_ban_reason bool +} +pub fn (o &CChatRoomGetBanListResponseBanInfo) pack() []byte { +mut res := []byte{} +if o.has_accountid { +res << vproto.pack_uint32_field(o.accountid, 1) +} + +if o.has_accountid_actor { +res << vproto.pack_uint32_field(o.accountid_actor, 2) +} + +if o.has_time_banned { +res << vproto.pack_uint32_field(o.time_banned, 3) +} + +if o.has_ban_reason { +res << vproto.pack_string_field(o.ban_reason, 4) +} + +return res +} + +pub fn cchatroomgetbanlistresponsebaninfo_unpack(buf []byte) ?CChatRoomGetBanListResponseBanInfo { +mut res := CChatRoomGetBanListResponseBanInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_accountid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.accountid = v +i = ii +} + +2 { +res.has_accountid_actor = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.accountid_actor = v +i = ii +} + +3 { +res.has_time_banned = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_banned = v +i = ii +} + +4 { +res.has_ban_reason = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.ban_reason = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgetbanlistresponsebaninfo() CChatRoomGetBanListResponseBanInfo { +return CChatRoomGetBanListResponseBanInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgetbanlistresponsebaninfo(o CChatRoomGetBanListResponseBanInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgetbanlistresponsebaninfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGetBanListResponseBanInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgetbanlistresponsebaninfo_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGetBanListResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +bans []CChatRoomGetBanListResponseBanInfo +} +pub fn (o &CChatRoomGetBanListResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.bans { +res << zzz_vproto_internal_pack_cchatroomgetbanlistresponsebaninfo(x, 1) +} + +return res +} + +pub fn cchatroomgetbanlistresponse_unpack(buf []byte) ?CChatRoomGetBanListResponse { +mut res := CChatRoomGetBanListResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cchatroomgetbanlistresponsebaninfo(cur_buf, tag_wiretype.wire_type)? +res.bans << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgetbanlistresponse() CChatRoomGetBanListResponse { +return CChatRoomGetBanListResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgetbanlistresponse(o CChatRoomGetBanListResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgetbanlistresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGetBanListResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgetbanlistresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGetInviteListRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +} +pub fn (o &CChatRoomGetInviteListRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +return res +} + +pub fn cchatroomgetinvitelistrequest_unpack(buf []byte) ?CChatRoomGetInviteListRequest { +mut res := CChatRoomGetInviteListRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgetinvitelistrequest() CChatRoomGetInviteListRequest { +return CChatRoomGetInviteListRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgetinvitelistrequest(o CChatRoomGetInviteListRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgetinvitelistrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGetInviteListRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgetinvitelistrequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGroupInvite { +mut: +unknown_fields []vproto.UnknownField +pub mut: +accountid u32 +has_accountid bool +accountid_actor u32 +has_accountid_actor bool +time_invited u32 +has_time_invited bool +} +pub fn (o &CChatRoomGroupInvite) pack() []byte { +mut res := []byte{} +if o.has_accountid { +res << vproto.pack_uint32_field(o.accountid, 1) +} + +if o.has_accountid_actor { +res << vproto.pack_uint32_field(o.accountid_actor, 2) +} + +if o.has_time_invited { +res << vproto.pack_uint32_field(o.time_invited, 3) +} + +return res +} + +pub fn cchatroomgroupinvite_unpack(buf []byte) ?CChatRoomGroupInvite { +mut res := CChatRoomGroupInvite{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_accountid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.accountid = v +i = ii +} + +2 { +res.has_accountid_actor = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.accountid_actor = v +i = ii +} + +3 { +res.has_time_invited = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_invited = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgroupinvite() CChatRoomGroupInvite { +return CChatRoomGroupInvite{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgroupinvite(o CChatRoomGroupInvite, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgroupinvite(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGroupInvite) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgroupinvite_unpack(v)? +return i, unpacked +} +pub struct CChatRoomGetInviteListResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +invites []CChatRoomGroupInvite +} +pub fn (o &CChatRoomGetInviteListResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.invites { +res << zzz_vproto_internal_pack_cchatroomgroupinvite(x, 1) +} + +return res +} + +pub fn cchatroomgetinvitelistresponse_unpack(buf []byte) ?CChatRoomGetInviteListResponse { +mut res := CChatRoomGetInviteListResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cchatroomgroupinvite(cur_buf, tag_wiretype.wire_type)? +res.invites << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomgetinvitelistresponse() CChatRoomGetInviteListResponse { +return CChatRoomGetInviteListResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomgetinvitelistresponse(o CChatRoomGetInviteListResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomgetinvitelistresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomGetInviteListResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomgetinvitelistresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomDeleteInviteLinkRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +invite_code string +has_invite_code bool +} +pub fn (o &CChatRoomDeleteInviteLinkRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_invite_code { +res << vproto.pack_string_field(o.invite_code, 2) +} + +return res +} + +pub fn cchatroomdeleteinvitelinkrequest_unpack(buf []byte) ?CChatRoomDeleteInviteLinkRequest { +mut res := CChatRoomDeleteInviteLinkRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_invite_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.invite_code = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomdeleteinvitelinkrequest() CChatRoomDeleteInviteLinkRequest { +return CChatRoomDeleteInviteLinkRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomdeleteinvitelinkrequest(o CChatRoomDeleteInviteLinkRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomdeleteinvitelinkrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomDeleteInviteLinkRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomdeleteinvitelinkrequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomDeleteInviteLinkResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CChatRoomDeleteInviteLinkResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cchatroomdeleteinvitelinkresponse_unpack(buf []byte) ?CChatRoomDeleteInviteLinkResponse { +res := CChatRoomDeleteInviteLinkResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomdeleteinvitelinkresponse() CChatRoomDeleteInviteLinkResponse { +return CChatRoomDeleteInviteLinkResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomdeleteinvitelinkresponse(o CChatRoomDeleteInviteLinkResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomdeleteinvitelinkresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomDeleteInviteLinkResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomdeleteinvitelinkresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomSetSessionActiveChatRoomGroupsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_ids []u64 +chat_groups_data_requested []u64 +virtualize_members_threshold int +has_virtualize_members_threshold bool +} +pub fn (o &CChatRoomSetSessionActiveChatRoomGroupsRequest) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.chat_group_ids { +res << vproto.pack_uint64_field(x, 1) +} + +// [packed=false] +for _, x in o.chat_groups_data_requested { +res << vproto.pack_uint64_field(x, 2) +} + +if o.has_virtualize_members_threshold { +res << vproto.pack_int32_field(o.virtualize_members_threshold, 3) +} + +return res +} + +pub fn cchatroomsetsessionactivechatroomgroupsrequest_unpack(buf []byte) ?CChatRoomSetSessionActiveChatRoomGroupsRequest { +mut res := CChatRoomSetSessionActiveChatRoomGroupsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_ids << v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_groups_data_requested << v +i = ii +} + +3 { +res.has_virtualize_members_threshold = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.virtualize_members_threshold = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomsetsessionactivechatroomgroupsrequest() CChatRoomSetSessionActiveChatRoomGroupsRequest { +return CChatRoomSetSessionActiveChatRoomGroupsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomsetsessionactivechatroomgroupsrequest(o CChatRoomSetSessionActiveChatRoomGroupsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomsetsessionactivechatroomgroupsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomSetSessionActiveChatRoomGroupsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomsetsessionactivechatroomgroupsrequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomSetSessionActiveChatRoomGroupsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_states []CChatRoomGroupState +virtualize_members_chat_group_ids []u64 +} +pub fn (o &CChatRoomSetSessionActiveChatRoomGroupsResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.chat_states { +res << zzz_vproto_internal_pack_cchatroomgroupstate(x, 1) +} + +// [packed=false] +for _, x in o.virtualize_members_chat_group_ids { +res << vproto.pack_uint64_field(x, 2) +} + +return res +} + +pub fn cchatroomsetsessionactivechatroomgroupsresponse_unpack(buf []byte) ?CChatRoomSetSessionActiveChatRoomGroupsResponse { +mut res := CChatRoomSetSessionActiveChatRoomGroupsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cchatroomgroupstate(cur_buf, tag_wiretype.wire_type)? +res.chat_states << v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.virtualize_members_chat_group_ids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomsetsessionactivechatroomgroupsresponse() CChatRoomSetSessionActiveChatRoomGroupsResponse { +return CChatRoomSetSessionActiveChatRoomGroupsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomsetsessionactivechatroomgroupsresponse(o CChatRoomSetSessionActiveChatRoomGroupsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomsetsessionactivechatroomgroupsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomSetSessionActiveChatRoomGroupsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomsetsessionactivechatroomgroupsresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomSetUserChatGroupPreferencesRequestChatGroupPreferences { +mut: +unknown_fields []vproto.UnknownField +pub mut: +desktop_notification_level EChatRoomNotificationLevel +has_desktop_notification_level bool +mobile_notification_level EChatRoomNotificationLevel +has_mobile_notification_level bool +unread_indicator_muted bool +has_unread_indicator_muted bool +} +pub fn (o &CChatRoomSetUserChatGroupPreferencesRequestChatGroupPreferences) pack() []byte { +mut res := []byte{} +if o.has_desktop_notification_level { +res << zzz_vproto_internal_pack_echatroomnotificationlevel(o.desktop_notification_level, 1) +} + +if o.has_mobile_notification_level { +res << zzz_vproto_internal_pack_echatroomnotificationlevel(o.mobile_notification_level, 2) +} + +if o.has_unread_indicator_muted { +res << vproto.pack_bool_field(o.unread_indicator_muted, 3) +} + +return res +} + +pub fn cchatroomsetuserchatgrouppreferencesrequestchatgrouppreferences_unpack(buf []byte) ?CChatRoomSetUserChatGroupPreferencesRequestChatGroupPreferences { +mut res := CChatRoomSetUserChatGroupPreferencesRequestChatGroupPreferences{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_desktop_notification_level = true +ii, v := zzz_vproto_internal_unpack_echatroomnotificationlevel(cur_buf, tag_wiretype.wire_type)? +res.desktop_notification_level = v +i = ii +} + +2 { +res.has_mobile_notification_level = true +ii, v := zzz_vproto_internal_unpack_echatroomnotificationlevel(cur_buf, tag_wiretype.wire_type)? +res.mobile_notification_level = v +i = ii +} + +3 { +res.has_unread_indicator_muted = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.unread_indicator_muted = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomsetuserchatgrouppreferencesrequestchatgrouppreferences() CChatRoomSetUserChatGroupPreferencesRequestChatGroupPreferences { +return CChatRoomSetUserChatGroupPreferencesRequestChatGroupPreferences{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomsetuserchatgrouppreferencesrequestchatgrouppreferences(o CChatRoomSetUserChatGroupPreferencesRequestChatGroupPreferences, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomsetuserchatgrouppreferencesrequestchatgrouppreferences(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomSetUserChatGroupPreferencesRequestChatGroupPreferences) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomsetuserchatgrouppreferencesrequestchatgrouppreferences_unpack(v)? +return i, unpacked +} +pub struct CChatRoomSetUserChatGroupPreferencesRequestChatRoomPreferences { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_id u64 +has_chat_id bool +desktop_notification_level EChatRoomNotificationLevel +has_desktop_notification_level bool +mobile_notification_level EChatRoomNotificationLevel +has_mobile_notification_level bool +unread_indicator_muted bool +has_unread_indicator_muted bool +} +pub fn (o &CChatRoomSetUserChatGroupPreferencesRequestChatRoomPreferences) pack() []byte { +mut res := []byte{} +if o.has_chat_id { +res << vproto.pack_uint64_field(o.chat_id, 1) +} + +if o.has_desktop_notification_level { +res << zzz_vproto_internal_pack_echatroomnotificationlevel(o.desktop_notification_level, 2) +} + +if o.has_mobile_notification_level { +res << zzz_vproto_internal_pack_echatroomnotificationlevel(o.mobile_notification_level, 3) +} + +if o.has_unread_indicator_muted { +res << vproto.pack_bool_field(o.unread_indicator_muted, 4) +} + +return res +} + +pub fn cchatroomsetuserchatgrouppreferencesrequestchatroompreferences_unpack(buf []byte) ?CChatRoomSetUserChatGroupPreferencesRequestChatRoomPreferences { +mut res := CChatRoomSetUserChatGroupPreferencesRequestChatRoomPreferences{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +2 { +res.has_desktop_notification_level = true +ii, v := zzz_vproto_internal_unpack_echatroomnotificationlevel(cur_buf, tag_wiretype.wire_type)? +res.desktop_notification_level = v +i = ii +} + +3 { +res.has_mobile_notification_level = true +ii, v := zzz_vproto_internal_unpack_echatroomnotificationlevel(cur_buf, tag_wiretype.wire_type)? +res.mobile_notification_level = v +i = ii +} + +4 { +res.has_unread_indicator_muted = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.unread_indicator_muted = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomsetuserchatgrouppreferencesrequestchatroompreferences() CChatRoomSetUserChatGroupPreferencesRequestChatRoomPreferences { +return CChatRoomSetUserChatGroupPreferencesRequestChatRoomPreferences{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomsetuserchatgrouppreferencesrequestchatroompreferences(o CChatRoomSetUserChatGroupPreferencesRequestChatRoomPreferences, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomsetuserchatgrouppreferencesrequestchatroompreferences(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomSetUserChatGroupPreferencesRequestChatRoomPreferences) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomsetuserchatgrouppreferencesrequestchatroompreferences_unpack(v)? +return i, unpacked +} +pub struct CChatRoomSetUserChatGroupPreferencesRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +chat_group_preferences CChatRoomSetUserChatGroupPreferencesRequestChatGroupPreferences +has_chat_group_preferences bool +chat_room_preferences []CChatRoomSetUserChatGroupPreferencesRequestChatRoomPreferences +} +pub fn (o &CChatRoomSetUserChatGroupPreferencesRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_chat_group_preferences { +res << zzz_vproto_internal_pack_cchatroomsetuserchatgrouppreferencesrequestchatgrouppreferences(o.chat_group_preferences, 2) +} + +// [packed=false] +for _, x in o.chat_room_preferences { +res << zzz_vproto_internal_pack_cchatroomsetuserchatgrouppreferencesrequestchatroompreferences(x, 3) +} + +return res +} + +pub fn cchatroomsetuserchatgrouppreferencesrequest_unpack(buf []byte) ?CChatRoomSetUserChatGroupPreferencesRequest { +mut res := CChatRoomSetUserChatGroupPreferencesRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_chat_group_preferences = true +ii, v := zzz_vproto_internal_unpack_cchatroomsetuserchatgrouppreferencesrequestchatgrouppreferences(cur_buf, tag_wiretype.wire_type)? +res.chat_group_preferences = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cchatroomsetuserchatgrouppreferencesrequestchatroompreferences(cur_buf, tag_wiretype.wire_type)? +res.chat_room_preferences << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomsetuserchatgrouppreferencesrequest() CChatRoomSetUserChatGroupPreferencesRequest { +return CChatRoomSetUserChatGroupPreferencesRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomsetuserchatgrouppreferencesrequest(o CChatRoomSetUserChatGroupPreferencesRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomsetuserchatgrouppreferencesrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomSetUserChatGroupPreferencesRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomsetuserchatgrouppreferencesrequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomSetUserChatGroupPreferencesResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CChatRoomSetUserChatGroupPreferencesResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cchatroomsetuserchatgrouppreferencesresponse_unpack(buf []byte) ?CChatRoomSetUserChatGroupPreferencesResponse { +res := CChatRoomSetUserChatGroupPreferencesResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomsetuserchatgrouppreferencesresponse() CChatRoomSetUserChatGroupPreferencesResponse { +return CChatRoomSetUserChatGroupPreferencesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomsetuserchatgrouppreferencesresponse(o CChatRoomSetUserChatGroupPreferencesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomsetuserchatgrouppreferencesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomSetUserChatGroupPreferencesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomsetuserchatgrouppreferencesresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomDeleteChatMessagesRequestMessage { +mut: +unknown_fields []vproto.UnknownField +pub mut: +server_timestamp u32 +has_server_timestamp bool +ordinal u32 +has_ordinal bool +} +pub fn (o &CChatRoomDeleteChatMessagesRequestMessage) pack() []byte { +mut res := []byte{} +if o.has_server_timestamp { +res << vproto.pack_uint32_field(o.server_timestamp, 1) +} + +if o.has_ordinal { +res << vproto.pack_uint32_field(o.ordinal, 2) +} + +return res +} + +pub fn cchatroomdeletechatmessagesrequestmessage_unpack(buf []byte) ?CChatRoomDeleteChatMessagesRequestMessage { +mut res := CChatRoomDeleteChatMessagesRequestMessage{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_server_timestamp = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.server_timestamp = v +i = ii +} + +2 { +res.has_ordinal = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ordinal = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomdeletechatmessagesrequestmessage() CChatRoomDeleteChatMessagesRequestMessage { +return CChatRoomDeleteChatMessagesRequestMessage{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomdeletechatmessagesrequestmessage(o CChatRoomDeleteChatMessagesRequestMessage, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomdeletechatmessagesrequestmessage(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomDeleteChatMessagesRequestMessage) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomdeletechatmessagesrequestmessage_unpack(v)? +return i, unpacked +} +pub struct CChatRoomDeleteChatMessagesRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +chat_id u64 +has_chat_id bool +messages []CChatRoomDeleteChatMessagesRequestMessage +} +pub fn (o &CChatRoomDeleteChatMessagesRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_chat_id { +res << vproto.pack_uint64_field(o.chat_id, 2) +} + +// [packed=false] +for _, x in o.messages { +res << zzz_vproto_internal_pack_cchatroomdeletechatmessagesrequestmessage(x, 3) +} + +return res +} + +pub fn cchatroomdeletechatmessagesrequest_unpack(buf []byte) ?CChatRoomDeleteChatMessagesRequest { +mut res := CChatRoomDeleteChatMessagesRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cchatroomdeletechatmessagesrequestmessage(cur_buf, tag_wiretype.wire_type)? +res.messages << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomdeletechatmessagesrequest() CChatRoomDeleteChatMessagesRequest { +return CChatRoomDeleteChatMessagesRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomdeletechatmessagesrequest(o CChatRoomDeleteChatMessagesRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomdeletechatmessagesrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomDeleteChatMessagesRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomdeletechatmessagesrequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomDeleteChatMessagesResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CChatRoomDeleteChatMessagesResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cchatroomdeletechatmessagesresponse_unpack(buf []byte) ?CChatRoomDeleteChatMessagesResponse { +res := CChatRoomDeleteChatMessagesResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomdeletechatmessagesresponse() CChatRoomDeleteChatMessagesResponse { +return CChatRoomDeleteChatMessagesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomdeletechatmessagesresponse(o CChatRoomDeleteChatMessagesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomdeletechatmessagesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomDeleteChatMessagesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomdeletechatmessagesresponse_unpack(v)? +return i, unpacked +} +pub struct CChatRoomUpdateMemberListViewNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +view_id u64 +has_view_id bool +start int +has_start bool +end int +has_end bool +client_changenumber int +has_client_changenumber bool +delete_view bool +has_delete_view bool +persona_subscribe_accountids []int +persona_unsubscribe_accountids []int +} +pub fn (o &CChatRoomUpdateMemberListViewNotification) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_view_id { +res << vproto.pack_uint64_field(o.view_id, 2) +} + +if o.has_start { +res << vproto.pack_int32_field(o.start, 3) +} + +if o.has_end { +res << vproto.pack_int32_field(o.end, 4) +} + +if o.has_client_changenumber { +res << vproto.pack_int32_field(o.client_changenumber, 5) +} + +if o.has_delete_view { +res << vproto.pack_bool_field(o.delete_view, 6) +} + +// [packed=false] +for _, x in o.persona_subscribe_accountids { +res << vproto.pack_int32_field(x, 7) +} + +// [packed=false] +for _, x in o.persona_unsubscribe_accountids { +res << vproto.pack_int32_field(x, 8) +} + +return res +} + +pub fn cchatroomupdatememberlistviewnotification_unpack(buf []byte) ?CChatRoomUpdateMemberListViewNotification { +mut res := CChatRoomUpdateMemberListViewNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_view_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.view_id = v +i = ii +} + +3 { +res.has_start = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.start = v +i = ii +} + +4 { +res.has_end = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.end = v +i = ii +} + +5 { +res.has_client_changenumber = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.client_changenumber = v +i = ii +} + +6 { +res.has_delete_view = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.delete_view = v +i = ii +} + +7 { +// [packed=false] +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.persona_subscribe_accountids << v +i = ii +} + +8 { +// [packed=false] +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.persona_unsubscribe_accountids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomupdatememberlistviewnotification() CChatRoomUpdateMemberListViewNotification { +return CChatRoomUpdateMemberListViewNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomupdatememberlistviewnotification(o CChatRoomUpdateMemberListViewNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomupdatememberlistviewnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomUpdateMemberListViewNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomupdatememberlistviewnotification_unpack(v)? +return i, unpacked +} +pub struct CChatRoomSearchMembersRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +search_id u64 +has_search_id bool +search_text string +has_search_text bool +max_results int +has_max_results bool +} +pub fn (o &CChatRoomSearchMembersRequest) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_search_id { +res << vproto.pack_uint64_field(o.search_id, 2) +} + +if o.has_search_text { +res << vproto.pack_string_field(o.search_text, 3) +} + +if o.has_max_results { +res << vproto.pack_int32_field(o.max_results, 4) +} + +return res +} + +pub fn cchatroomsearchmembersrequest_unpack(buf []byte) ?CChatRoomSearchMembersRequest { +mut res := CChatRoomSearchMembersRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_search_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.search_id = v +i = ii +} + +3 { +res.has_search_text = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.search_text = v +i = ii +} + +4 { +res.has_max_results = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.max_results = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomsearchmembersrequest() CChatRoomSearchMembersRequest { +return CChatRoomSearchMembersRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomsearchmembersrequest(o CChatRoomSearchMembersRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomsearchmembersrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomSearchMembersRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomsearchmembersrequest_unpack(v)? +return i, unpacked +} +pub struct CChatRoomSearchMembersResponseMemberMatch { +mut: +unknown_fields []vproto.UnknownField +pub mut: +accountid int +has_accountid bool +persona CMsgClientPersonaStateFriend +has_persona bool +} +pub fn (o &CChatRoomSearchMembersResponseMemberMatch) pack() []byte { +mut res := []byte{} +if o.has_accountid { +res << vproto.pack_int32_field(o.accountid, 1) +} + +if o.has_persona { +res << zzz_vproto_internal_pack_cmsgclientpersonastatefriend(o.persona, 2) +} + +return res +} + +pub fn cchatroomsearchmembersresponsemembermatch_unpack(buf []byte) ?CChatRoomSearchMembersResponseMemberMatch { +mut res := CChatRoomSearchMembersResponseMemberMatch{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_accountid = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.accountid = v +i = ii +} + +2 { +res.has_persona = true +ii, v := zzz_vproto_internal_unpack_cmsgclientpersonastatefriend(cur_buf, tag_wiretype.wire_type)? +res.persona = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomsearchmembersresponsemembermatch() CChatRoomSearchMembersResponseMemberMatch { +return CChatRoomSearchMembersResponseMemberMatch{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomsearchmembersresponsemembermatch(o CChatRoomSearchMembersResponseMemberMatch, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomsearchmembersresponsemembermatch(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomSearchMembersResponseMemberMatch) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomsearchmembersresponsemembermatch_unpack(v)? +return i, unpacked +} +pub struct CChatRoomSearchMembersResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +matching_members []CChatRoomSearchMembersResponseMemberMatch +status_flags u32 +has_status_flags bool +} +pub fn (o &CChatRoomSearchMembersResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.matching_members { +res << zzz_vproto_internal_pack_cchatroomsearchmembersresponsemembermatch(x, 1) +} + +if o.has_status_flags { +res << vproto.pack_uint32_field(o.status_flags, 2) +} + +return res +} + +pub fn cchatroomsearchmembersresponse_unpack(buf []byte) ?CChatRoomSearchMembersResponse { +mut res := CChatRoomSearchMembersResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cchatroomsearchmembersresponsemembermatch(cur_buf, tag_wiretype.wire_type)? +res.matching_members << v +i = ii +} + +2 { +res.has_status_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.status_flags = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomsearchmembersresponse() CChatRoomSearchMembersResponse { +return CChatRoomSearchMembersResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomsearchmembersresponse(o CChatRoomSearchMembersResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomsearchmembersresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomSearchMembersResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomsearchmembersresponse_unpack(v)? +return i, unpacked +} +pub struct CClanChatRoomsGetClanChatRoomInfoRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +autocreate bool +has_autocreate bool +} +pub fn (o &CClanChatRoomsGetClanChatRoomInfoRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_autocreate { +res << vproto.pack_bool_field(o.autocreate, 2) +} + +return res +} + +pub fn cclanchatroomsgetclanchatroominforequest_unpack(buf []byte) ?CClanChatRoomsGetClanChatRoomInfoRequest { +mut res := CClanChatRoomsGetClanChatRoomInfoRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_autocreate = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.autocreate = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cclanchatroomsgetclanchatroominforequest() CClanChatRoomsGetClanChatRoomInfoRequest { +return CClanChatRoomsGetClanChatRoomInfoRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cclanchatroomsgetclanchatroominforequest(o CClanChatRoomsGetClanChatRoomInfoRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cclanchatroomsgetclanchatroominforequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CClanChatRoomsGetClanChatRoomInfoRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cclanchatroomsgetclanchatroominforequest_unpack(v)? +return i, unpacked +} +pub struct CClanChatRoomsGetClanChatRoomInfoResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_summary CChatRoomGetChatRoomGroupSummaryResponse +has_chat_group_summary bool +} +pub fn (o &CClanChatRoomsGetClanChatRoomInfoResponse) pack() []byte { +mut res := []byte{} +if o.has_chat_group_summary { +res << zzz_vproto_internal_pack_cchatroomgetchatroomgroupsummaryresponse(o.chat_group_summary, 1) +} + +return res +} + +pub fn cclanchatroomsgetclanchatroominforesponse_unpack(buf []byte) ?CClanChatRoomsGetClanChatRoomInfoResponse { +mut res := CClanChatRoomsGetClanChatRoomInfoResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_summary = true +ii, v := zzz_vproto_internal_unpack_cchatroomgetchatroomgroupsummaryresponse(cur_buf, tag_wiretype.wire_type)? +res.chat_group_summary = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cclanchatroomsgetclanchatroominforesponse() CClanChatRoomsGetClanChatRoomInfoResponse { +return CClanChatRoomsGetClanChatRoomInfoResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cclanchatroomsgetclanchatroominforesponse(o CClanChatRoomsGetClanChatRoomInfoResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cclanchatroomsgetclanchatroominforesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CClanChatRoomsGetClanChatRoomInfoResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cclanchatroomsgetclanchatroominforesponse_unpack(v)? +return i, unpacked +} +pub struct CClanChatRoomsSetClanChatRoomPrivateRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +chat_room_private bool +has_chat_room_private bool +} +pub fn (o &CClanChatRoomsSetClanChatRoomPrivateRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_chat_room_private { +res << vproto.pack_bool_field(o.chat_room_private, 2) +} + +return res +} + +pub fn cclanchatroomssetclanchatroomprivaterequest_unpack(buf []byte) ?CClanChatRoomsSetClanChatRoomPrivateRequest { +mut res := CClanChatRoomsSetClanChatRoomPrivateRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_chat_room_private = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.chat_room_private = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cclanchatroomssetclanchatroomprivaterequest() CClanChatRoomsSetClanChatRoomPrivateRequest { +return CClanChatRoomsSetClanChatRoomPrivateRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cclanchatroomssetclanchatroomprivaterequest(o CClanChatRoomsSetClanChatRoomPrivateRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cclanchatroomssetclanchatroomprivaterequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CClanChatRoomsSetClanChatRoomPrivateRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cclanchatroomssetclanchatroomprivaterequest_unpack(v)? +return i, unpacked +} +pub struct CClanChatRoomsSetClanChatRoomPrivateResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_room_private bool +has_chat_room_private bool +} +pub fn (o &CClanChatRoomsSetClanChatRoomPrivateResponse) pack() []byte { +mut res := []byte{} +if o.has_chat_room_private { +res << vproto.pack_bool_field(o.chat_room_private, 1) +} + +return res +} + +pub fn cclanchatroomssetclanchatroomprivateresponse_unpack(buf []byte) ?CClanChatRoomsSetClanChatRoomPrivateResponse { +mut res := CClanChatRoomsSetClanChatRoomPrivateResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_room_private = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.chat_room_private = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cclanchatroomssetclanchatroomprivateresponse() CClanChatRoomsSetClanChatRoomPrivateResponse { +return CClanChatRoomsSetClanChatRoomPrivateResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cclanchatroomssetclanchatroomprivateresponse(o CClanChatRoomsSetClanChatRoomPrivateResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cclanchatroomssetclanchatroomprivateresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CClanChatRoomsSetClanChatRoomPrivateResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cclanchatroomssetclanchatroomprivateresponse_unpack(v)? +return i, unpacked +} +pub struct CChatMentions { +mut: +unknown_fields []vproto.UnknownField +pub mut: +mention_all bool +has_mention_all bool +mention_here bool +has_mention_here bool +mention_accountids []u32 +} +pub fn (o &CChatMentions) pack() []byte { +mut res := []byte{} +if o.has_mention_all { +res << vproto.pack_bool_field(o.mention_all, 1) +} + +if o.has_mention_here { +res << vproto.pack_bool_field(o.mention_here, 2) +} + +// [packed=false] +for _, x in o.mention_accountids { +res << vproto.pack_uint32_field(x, 3) +} + +return res +} + +pub fn cchatmentions_unpack(buf []byte) ?CChatMentions { +mut res := CChatMentions{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_mention_all = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.mention_all = v +i = ii +} + +2 { +res.has_mention_here = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.mention_here = v +i = ii +} + +3 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.mention_accountids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatmentions() CChatMentions { +return CChatMentions{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatmentions(o CChatMentions, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatmentions(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatMentions) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatmentions_unpack(v)? +return i, unpacked +} +pub struct CChatRoomIncomingChatMessageNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +chat_id u64 +has_chat_id bool +steamid_sender u64 +has_steamid_sender bool +message string +has_message bool +timestamp u32 +has_timestamp bool +mentions CChatMentions +has_mentions bool +ordinal u32 +has_ordinal bool +server_message ServerMessage +has_server_message bool +message_no_bbcode string +has_message_no_bbcode bool +chat_name string +has_chat_name bool +} +pub fn (o &CChatRoomIncomingChatMessageNotification) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_chat_id { +res << vproto.pack_uint64_field(o.chat_id, 2) +} + +if o.has_steamid_sender { +res << vproto.pack_64bit_field(o.steamid_sender, 3) +} + +if o.has_message { +res << vproto.pack_string_field(o.message, 4) +} + +if o.has_timestamp { +res << vproto.pack_uint32_field(o.timestamp, 5) +} + +if o.has_mentions { +res << zzz_vproto_internal_pack_cchatmentions(o.mentions, 6) +} + +if o.has_ordinal { +res << vproto.pack_uint32_field(o.ordinal, 7) +} + +if o.has_server_message { +res << zzz_vproto_internal_pack_servermessage(o.server_message, 8) +} + +if o.has_message_no_bbcode { +res << vproto.pack_string_field(o.message_no_bbcode, 9) +} + +if o.has_chat_name { +res << vproto.pack_string_field(o.chat_name, 10) +} + +return res +} + +pub fn cchatroomincomingchatmessagenotification_unpack(buf []byte) ?CChatRoomIncomingChatMessageNotification { +mut res := CChatRoomIncomingChatMessageNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +3 { +res.has_steamid_sender = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_sender = v +i = ii +} + +4 { +res.has_message = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.message = v +i = ii +} + +5 { +res.has_timestamp = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp = v +i = ii +} + +6 { +res.has_mentions = true +ii, v := zzz_vproto_internal_unpack_cchatmentions(cur_buf, tag_wiretype.wire_type)? +res.mentions = v +i = ii +} + +7 { +res.has_ordinal = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ordinal = v +i = ii +} + +8 { +res.has_server_message = true +ii, v := zzz_vproto_internal_unpack_servermessage(cur_buf, tag_wiretype.wire_type)? +res.server_message = v +i = ii +} + +9 { +res.has_message_no_bbcode = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.message_no_bbcode = v +i = ii +} + +10 { +res.has_chat_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.chat_name = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomincomingchatmessagenotification() CChatRoomIncomingChatMessageNotification { +return CChatRoomIncomingChatMessageNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomincomingchatmessagenotification(o CChatRoomIncomingChatMessageNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomincomingchatmessagenotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomIncomingChatMessageNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomincomingchatmessagenotification_unpack(v)? +return i, unpacked +} +pub struct CChatRoomChatMessageModifiedNotificationChatMessage { +mut: +unknown_fields []vproto.UnknownField +pub mut: +server_timestamp u32 +has_server_timestamp bool +ordinal u32 +has_ordinal bool +deleted bool +has_deleted bool +} +pub fn (o &CChatRoomChatMessageModifiedNotificationChatMessage) pack() []byte { +mut res := []byte{} +if o.has_server_timestamp { +res << vproto.pack_uint32_field(o.server_timestamp, 1) +} + +if o.has_ordinal { +res << vproto.pack_uint32_field(o.ordinal, 2) +} + +if o.has_deleted { +res << vproto.pack_bool_field(o.deleted, 3) +} + +return res +} + +pub fn cchatroomchatmessagemodifiednotificationchatmessage_unpack(buf []byte) ?CChatRoomChatMessageModifiedNotificationChatMessage { +mut res := CChatRoomChatMessageModifiedNotificationChatMessage{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_server_timestamp = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.server_timestamp = v +i = ii +} + +2 { +res.has_ordinal = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ordinal = v +i = ii +} + +3 { +res.has_deleted = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.deleted = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomchatmessagemodifiednotificationchatmessage() CChatRoomChatMessageModifiedNotificationChatMessage { +return CChatRoomChatMessageModifiedNotificationChatMessage{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomchatmessagemodifiednotificationchatmessage(o CChatRoomChatMessageModifiedNotificationChatMessage, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomchatmessagemodifiednotificationchatmessage(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomChatMessageModifiedNotificationChatMessage) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomchatmessagemodifiednotificationchatmessage_unpack(v)? +return i, unpacked +} +pub struct CChatRoomChatMessageModifiedNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +chat_id u64 +has_chat_id bool +messages []CChatRoomChatMessageModifiedNotificationChatMessage +} +pub fn (o &CChatRoomChatMessageModifiedNotification) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_chat_id { +res << vproto.pack_uint64_field(o.chat_id, 2) +} + +// [packed=false] +for _, x in o.messages { +res << zzz_vproto_internal_pack_cchatroomchatmessagemodifiednotificationchatmessage(x, 3) +} + +return res +} + +pub fn cchatroomchatmessagemodifiednotification_unpack(buf []byte) ?CChatRoomChatMessageModifiedNotification { +mut res := CChatRoomChatMessageModifiedNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cchatroomchatmessagemodifiednotificationchatmessage(cur_buf, tag_wiretype.wire_type)? +res.messages << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomchatmessagemodifiednotification() CChatRoomChatMessageModifiedNotification { +return CChatRoomChatMessageModifiedNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomchatmessagemodifiednotification(o CChatRoomChatMessageModifiedNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomchatmessagemodifiednotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomChatMessageModifiedNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomchatmessagemodifiednotification_unpack(v)? +return i, unpacked +} +pub struct CChatRoomMemberStateChangeNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +member CChatRoomMember +has_member bool +change EChatRoomMemberStateChange +has_change bool +} +pub fn (o &CChatRoomMemberStateChangeNotification) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_member { +res << zzz_vproto_internal_pack_cchatroommember(o.member, 2) +} + +if o.has_change { +res << zzz_vproto_internal_pack_echatroommemberstatechange(o.change, 3) +} + +return res +} + +pub fn cchatroommemberstatechangenotification_unpack(buf []byte) ?CChatRoomMemberStateChangeNotification { +mut res := CChatRoomMemberStateChangeNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_member = true +ii, v := zzz_vproto_internal_unpack_cchatroommember(cur_buf, tag_wiretype.wire_type)? +res.member = v +i = ii +} + +3 { +res.has_change = true +ii, v := zzz_vproto_internal_unpack_echatroommemberstatechange(cur_buf, tag_wiretype.wire_type)? +res.change = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroommemberstatechangenotification() CChatRoomMemberStateChangeNotification { +return CChatRoomMemberStateChangeNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroommemberstatechangenotification(o CChatRoomMemberStateChangeNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroommemberstatechangenotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomMemberStateChangeNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroommemberstatechangenotification_unpack(v)? +return i, unpacked +} +pub struct CChatRoomChatRoomHeaderStateNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +header_state CChatRoomGroupHeaderState +has_header_state bool +} +pub fn (o &CChatRoomChatRoomHeaderStateNotification) pack() []byte { +mut res := []byte{} +if o.has_header_state { +res << zzz_vproto_internal_pack_cchatroomgroupheaderstate(o.header_state, 1) +} + +return res +} + +pub fn cchatroomchatroomheaderstatenotification_unpack(buf []byte) ?CChatRoomChatRoomHeaderStateNotification { +mut res := CChatRoomChatRoomHeaderStateNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_header_state = true +ii, v := zzz_vproto_internal_unpack_cchatroomgroupheaderstate(cur_buf, tag_wiretype.wire_type)? +res.header_state = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomchatroomheaderstatenotification() CChatRoomChatRoomHeaderStateNotification { +return CChatRoomChatRoomHeaderStateNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomchatroomheaderstatenotification(o CChatRoomChatRoomHeaderStateNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomchatroomheaderstatenotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomChatRoomHeaderStateNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomchatroomheaderstatenotification_unpack(v)? +return i, unpacked +} +pub struct CChatRoomChatRoomGroupRoomsChangeNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +default_chat_id u64 +has_default_chat_id bool +chat_rooms []CChatRoomState +} +pub fn (o &CChatRoomChatRoomGroupRoomsChangeNotification) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_default_chat_id { +res << vproto.pack_uint64_field(o.default_chat_id, 2) +} + +// [packed=false] +for _, x in o.chat_rooms { +res << zzz_vproto_internal_pack_cchatroomstate(x, 3) +} + +return res +} + +pub fn cchatroomchatroomgrouproomschangenotification_unpack(buf []byte) ?CChatRoomChatRoomGroupRoomsChangeNotification { +mut res := CChatRoomChatRoomGroupRoomsChangeNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_default_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.default_chat_id = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cchatroomstate(cur_buf, tag_wiretype.wire_type)? +res.chat_rooms << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomchatroomgrouproomschangenotification() CChatRoomChatRoomGroupRoomsChangeNotification { +return CChatRoomChatRoomGroupRoomsChangeNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomchatroomgrouproomschangenotification(o CChatRoomChatRoomGroupRoomsChangeNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomchatroomgrouproomschangenotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomChatRoomGroupRoomsChangeNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomchatroomgrouproomschangenotification_unpack(v)? +return i, unpacked +} +pub struct CChatRoomNotifyShouldRejoinChatRoomVoiceChatNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_id u64 +has_chat_id bool +chat_group_id u64 +has_chat_group_id bool +} +pub fn (o &CChatRoomNotifyShouldRejoinChatRoomVoiceChatNotification) pack() []byte { +mut res := []byte{} +if o.has_chat_id { +res << vproto.pack_uint64_field(o.chat_id, 1) +} + +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 2) +} + +return res +} + +pub fn cchatroomnotifyshouldrejoinchatroomvoicechatnotification_unpack(buf []byte) ?CChatRoomNotifyShouldRejoinChatRoomVoiceChatNotification { +mut res := CChatRoomNotifyShouldRejoinChatRoomVoiceChatNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_id = v +i = ii +} + +2 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomnotifyshouldrejoinchatroomvoicechatnotification() CChatRoomNotifyShouldRejoinChatRoomVoiceChatNotification { +return CChatRoomNotifyShouldRejoinChatRoomVoiceChatNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomnotifyshouldrejoinchatroomvoicechatnotification(o CChatRoomNotifyShouldRejoinChatRoomVoiceChatNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomnotifyshouldrejoinchatroomvoicechatnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomNotifyShouldRejoinChatRoomVoiceChatNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomnotifyshouldrejoinchatroomvoicechatnotification_unpack(v)? +return i, unpacked +} +pub struct ChatRoomClientNotifyChatGroupUserStateChangedNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +user_chat_group_state CUserChatRoomGroupState +has_user_chat_group_state bool +group_summary CChatRoomGetChatRoomGroupSummaryResponse +has_group_summary bool +user_action EChatRoomMemberStateChange +has_user_action bool +} +pub fn (o &ChatRoomClientNotifyChatGroupUserStateChangedNotification) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_user_chat_group_state { +res << zzz_vproto_internal_pack_cuserchatroomgroupstate(o.user_chat_group_state, 2) +} + +if o.has_group_summary { +res << zzz_vproto_internal_pack_cchatroomgetchatroomgroupsummaryresponse(o.group_summary, 3) +} + +if o.has_user_action { +res << zzz_vproto_internal_pack_echatroommemberstatechange(o.user_action, 4) +} + +return res +} + +pub fn chatroomclientnotifychatgroupuserstatechangednotification_unpack(buf []byte) ?ChatRoomClientNotifyChatGroupUserStateChangedNotification { +mut res := ChatRoomClientNotifyChatGroupUserStateChangedNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_user_chat_group_state = true +ii, v := zzz_vproto_internal_unpack_cuserchatroomgroupstate(cur_buf, tag_wiretype.wire_type)? +res.user_chat_group_state = v +i = ii +} + +3 { +res.has_group_summary = true +ii, v := zzz_vproto_internal_unpack_cchatroomgetchatroomgroupsummaryresponse(cur_buf, tag_wiretype.wire_type)? +res.group_summary = v +i = ii +} + +4 { +res.has_user_action = true +ii, v := zzz_vproto_internal_unpack_echatroommemberstatechange(cur_buf, tag_wiretype.wire_type)? +res.user_action = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_chatroomclientnotifychatgroupuserstatechangednotification() ChatRoomClientNotifyChatGroupUserStateChangedNotification { +return ChatRoomClientNotifyChatGroupUserStateChangedNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_chatroomclientnotifychatgroupuserstatechangednotification(o ChatRoomClientNotifyChatGroupUserStateChangedNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_chatroomclientnotifychatgroupuserstatechangednotification(buf []byte, tag_wiretype vproto.WireType) ?(int, ChatRoomClientNotifyChatGroupUserStateChangedNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := chatroomclientnotifychatgroupuserstatechangednotification_unpack(v)? +return i, unpacked +} +pub struct ChatRoomClientNotifyChatRoomDisconnectNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_ids []u64 +} +pub fn (o &ChatRoomClientNotifyChatRoomDisconnectNotification) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.chat_group_ids { +res << vproto.pack_uint64_field(x, 1) +} + +return res +} + +pub fn chatroomclientnotifychatroomdisconnectnotification_unpack(buf []byte) ?ChatRoomClientNotifyChatRoomDisconnectNotification { +mut res := ChatRoomClientNotifyChatRoomDisconnectNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_ids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_chatroomclientnotifychatroomdisconnectnotification() ChatRoomClientNotifyChatRoomDisconnectNotification { +return ChatRoomClientNotifyChatRoomDisconnectNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_chatroomclientnotifychatroomdisconnectnotification(o ChatRoomClientNotifyChatRoomDisconnectNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_chatroomclientnotifychatroomdisconnectnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, ChatRoomClientNotifyChatRoomDisconnectNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := chatroomclientnotifychatroomdisconnectnotification_unpack(v)? +return i, unpacked +} +pub struct CChatRoomMemberListView { +mut: +unknown_fields []vproto.UnknownField +pub mut: +start int +has_start bool +end int +has_end bool +total_count int +has_total_count bool +client_changenumber int +has_client_changenumber bool +server_changenumber int +has_server_changenumber bool +} +pub fn (o &CChatRoomMemberListView) pack() []byte { +mut res := []byte{} +if o.has_start { +res << vproto.pack_int32_field(o.start, 3) +} + +if o.has_end { +res << vproto.pack_int32_field(o.end, 4) +} + +if o.has_total_count { +res << vproto.pack_int32_field(o.total_count, 5) +} + +if o.has_client_changenumber { +res << vproto.pack_int32_field(o.client_changenumber, 6) +} + +if o.has_server_changenumber { +res << vproto.pack_int32_field(o.server_changenumber, 7) +} + +return res +} + +pub fn cchatroommemberlistview_unpack(buf []byte) ?CChatRoomMemberListView { +mut res := CChatRoomMemberListView{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +3 { +res.has_start = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.start = v +i = ii +} + +4 { +res.has_end = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.end = v +i = ii +} + +5 { +res.has_total_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.total_count = v +i = ii +} + +6 { +res.has_client_changenumber = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.client_changenumber = v +i = ii +} + +7 { +res.has_server_changenumber = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.server_changenumber = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroommemberlistview() CChatRoomMemberListView { +return CChatRoomMemberListView{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroommemberlistview(o CChatRoomMemberListView, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroommemberlistview(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomMemberListView) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroommemberlistview_unpack(v)? +return i, unpacked +} +pub struct CChatRoomMemberSummaryCounts { +mut: +unknown_fields []vproto.UnknownField +pub mut: +ingame int +has_ingame bool +online int +has_online bool +offline int +has_offline bool +} +pub fn (o &CChatRoomMemberSummaryCounts) pack() []byte { +mut res := []byte{} +if o.has_ingame { +res << vproto.pack_int32_field(o.ingame, 1) +} + +if o.has_online { +res << vproto.pack_int32_field(o.online, 2) +} + +if o.has_offline { +res << vproto.pack_int32_field(o.offline, 3) +} + +return res +} + +pub fn cchatroommembersummarycounts_unpack(buf []byte) ?CChatRoomMemberSummaryCounts { +mut res := CChatRoomMemberSummaryCounts{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_ingame = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.ingame = v +i = ii +} + +2 { +res.has_online = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.online = v +i = ii +} + +3 { +res.has_offline = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.offline = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroommembersummarycounts() CChatRoomMemberSummaryCounts { +return CChatRoomMemberSummaryCounts{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroommembersummarycounts(o CChatRoomMemberSummaryCounts, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroommembersummarycounts(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomMemberSummaryCounts) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroommembersummarycounts_unpack(v)? +return i, unpacked +} +pub struct CChatRoomClientMemberListViewUpdatedNotificationMemberListViewEntry { +mut: +unknown_fields []vproto.UnknownField +pub mut: +rank int +has_rank bool +accountid u32 +has_accountid bool +persona CMsgClientPersonaStateFriend +has_persona bool +} +pub fn (o &CChatRoomClientMemberListViewUpdatedNotificationMemberListViewEntry) pack() []byte { +mut res := []byte{} +if o.has_rank { +res << vproto.pack_int32_field(o.rank, 1) +} + +if o.has_accountid { +res << vproto.pack_uint32_field(o.accountid, 2) +} + +if o.has_persona { +res << zzz_vproto_internal_pack_cmsgclientpersonastatefriend(o.persona, 3) +} + +return res +} + +pub fn cchatroomclientmemberlistviewupdatednotificationmemberlistviewentry_unpack(buf []byte) ?CChatRoomClientMemberListViewUpdatedNotificationMemberListViewEntry { +mut res := CChatRoomClientMemberListViewUpdatedNotificationMemberListViewEntry{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_rank = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.rank = v +i = ii +} + +2 { +res.has_accountid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.accountid = v +i = ii +} + +3 { +res.has_persona = true +ii, v := zzz_vproto_internal_unpack_cmsgclientpersonastatefriend(cur_buf, tag_wiretype.wire_type)? +res.persona = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomclientmemberlistviewupdatednotificationmemberlistviewentry() CChatRoomClientMemberListViewUpdatedNotificationMemberListViewEntry { +return CChatRoomClientMemberListViewUpdatedNotificationMemberListViewEntry{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomclientmemberlistviewupdatednotificationmemberlistviewentry(o CChatRoomClientMemberListViewUpdatedNotificationMemberListViewEntry, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomclientmemberlistviewupdatednotificationmemberlistviewentry(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomClientMemberListViewUpdatedNotificationMemberListViewEntry) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomclientmemberlistviewupdatednotificationmemberlistviewentry_unpack(v)? +return i, unpacked +} +pub struct CChatRoomClientMemberListViewUpdatedNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chat_group_id u64 +has_chat_group_id bool +view_id u64 +has_view_id bool +view CChatRoomMemberListView +has_view bool +members []CChatRoomClientMemberListViewUpdatedNotificationMemberListViewEntry +status_flags u32 +has_status_flags bool +member_summary CChatRoomMemberSummaryCounts +has_member_summary bool +subscribed_personas []CMsgClientPersonaStateFriend +} +pub fn (o &CChatRoomClientMemberListViewUpdatedNotification) pack() []byte { +mut res := []byte{} +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 1) +} + +if o.has_view_id { +res << vproto.pack_uint64_field(o.view_id, 2) +} + +if o.has_view { +res << zzz_vproto_internal_pack_cchatroommemberlistview(o.view, 3) +} + +// [packed=false] +for _, x in o.members { +res << zzz_vproto_internal_pack_cchatroomclientmemberlistviewupdatednotificationmemberlistviewentry(x, 4) +} + +if o.has_status_flags { +res << vproto.pack_uint32_field(o.status_flags, 5) +} + +if o.has_member_summary { +res << zzz_vproto_internal_pack_cchatroommembersummarycounts(o.member_summary, 6) +} + +// [packed=false] +for _, x in o.subscribed_personas { +res << zzz_vproto_internal_pack_cmsgclientpersonastatefriend(x, 7) +} + +return res +} + +pub fn cchatroomclientmemberlistviewupdatednotification_unpack(buf []byte) ?CChatRoomClientMemberListViewUpdatedNotification { +mut res := CChatRoomClientMemberListViewUpdatedNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +2 { +res.has_view_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.view_id = v +i = ii +} + +3 { +res.has_view = true +ii, v := zzz_vproto_internal_unpack_cchatroommemberlistview(cur_buf, tag_wiretype.wire_type)? +res.view = v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cchatroomclientmemberlistviewupdatednotificationmemberlistviewentry(cur_buf, tag_wiretype.wire_type)? +res.members << v +i = ii +} + +5 { +res.has_status_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.status_flags = v +i = ii +} + +6 { +res.has_member_summary = true +ii, v := zzz_vproto_internal_unpack_cchatroommembersummarycounts(cur_buf, tag_wiretype.wire_type)? +res.member_summary = v +i = ii +} + +7 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientpersonastatefriend(cur_buf, tag_wiretype.wire_type)? +res.subscribed_personas << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatroomclientmemberlistviewupdatednotification() CChatRoomClientMemberListViewUpdatedNotification { +return CChatRoomClientMemberListViewUpdatedNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatroomclientmemberlistviewupdatednotification(o CChatRoomClientMemberListViewUpdatedNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatroomclientmemberlistviewupdatednotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatRoomClientMemberListViewUpdatedNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatroomclientmemberlistviewupdatednotification_unpack(v)? +return i, unpacked +} +pub struct CChatUsabilityClientUsabilityMetricsNotificationSettings { +mut: +unknown_fields []vproto.UnknownField +pub mut: +notifications_show_ingame bool +has_notifications_show_ingame bool +notifications_show_online bool +has_notifications_show_online bool +notifications_show_message bool +has_notifications_show_message bool +notifications_events_and_announcements bool +has_notifications_events_and_announcements bool +sounds_play_ingame bool +has_sounds_play_ingame bool +sounds_play_online bool +has_sounds_play_online bool +sounds_play_message bool +has_sounds_play_message bool +sounds_events_and_announcements bool +has_sounds_events_and_announcements bool +always_new_chat_window bool +has_always_new_chat_window bool +force_alphabetic_friend_sorting bool +has_force_alphabetic_friend_sorting bool +chat_flash_mode int +has_chat_flash_mode bool +remember_open_chats bool +has_remember_open_chats bool +compact_quick_access bool +has_compact_quick_access bool +compact_friends_list bool +has_compact_friends_list bool +notifications_show_chat_room_notification bool +has_notifications_show_chat_room_notification bool +sounds_play_chat_room_notification bool +has_sounds_play_chat_room_notification bool +hide_offline_friends_in_tag_groups bool +has_hide_offline_friends_in_tag_groups bool +hide_categorized_friends bool +has_hide_categorized_friends bool +categorize_in_game_friends_by_game bool +has_categorize_in_game_friends_by_game bool +chat_font_size int +has_chat_font_size bool +use24hour_clock bool +has_use24hour_clock bool +do_not_disturb_mode bool +has_do_not_disturb_mode bool +disable_embed_inlining bool +has_disable_embed_inlining bool +sign_into_friends bool +has_sign_into_friends bool +animated_avatars bool +has_animated_avatars bool +} +pub fn (o &CChatUsabilityClientUsabilityMetricsNotificationSettings) pack() []byte { +mut res := []byte{} +if o.has_notifications_show_ingame { +res << vproto.pack_bool_field(o.notifications_show_ingame, 1) +} + +if o.has_notifications_show_online { +res << vproto.pack_bool_field(o.notifications_show_online, 2) +} + +if o.has_notifications_show_message { +res << vproto.pack_bool_field(o.notifications_show_message, 3) +} + +if o.has_notifications_events_and_announcements { +res << vproto.pack_bool_field(o.notifications_events_and_announcements, 4) +} + +if o.has_sounds_play_ingame { +res << vproto.pack_bool_field(o.sounds_play_ingame, 5) +} + +if o.has_sounds_play_online { +res << vproto.pack_bool_field(o.sounds_play_online, 6) +} + +if o.has_sounds_play_message { +res << vproto.pack_bool_field(o.sounds_play_message, 7) +} + +if o.has_sounds_events_and_announcements { +res << vproto.pack_bool_field(o.sounds_events_and_announcements, 8) +} + +if o.has_always_new_chat_window { +res << vproto.pack_bool_field(o.always_new_chat_window, 9) +} + +if o.has_force_alphabetic_friend_sorting { +res << vproto.pack_bool_field(o.force_alphabetic_friend_sorting, 10) +} + +if o.has_chat_flash_mode { +res << vproto.pack_int32_field(o.chat_flash_mode, 11) +} + +if o.has_remember_open_chats { +res << vproto.pack_bool_field(o.remember_open_chats, 12) +} + +if o.has_compact_quick_access { +res << vproto.pack_bool_field(o.compact_quick_access, 13) +} + +if o.has_compact_friends_list { +res << vproto.pack_bool_field(o.compact_friends_list, 14) +} + +if o.has_notifications_show_chat_room_notification { +res << vproto.pack_bool_field(o.notifications_show_chat_room_notification, 15) +} + +if o.has_sounds_play_chat_room_notification { +res << vproto.pack_bool_field(o.sounds_play_chat_room_notification, 16) +} + +if o.has_hide_offline_friends_in_tag_groups { +res << vproto.pack_bool_field(o.hide_offline_friends_in_tag_groups, 17) +} + +if o.has_hide_categorized_friends { +res << vproto.pack_bool_field(o.hide_categorized_friends, 18) +} + +if o.has_categorize_in_game_friends_by_game { +res << vproto.pack_bool_field(o.categorize_in_game_friends_by_game, 19) +} + +if o.has_chat_font_size { +res << vproto.pack_int32_field(o.chat_font_size, 20) +} + +if o.has_use24hour_clock { +res << vproto.pack_bool_field(o.use24hour_clock, 21) +} + +if o.has_do_not_disturb_mode { +res << vproto.pack_bool_field(o.do_not_disturb_mode, 22) +} + +if o.has_disable_embed_inlining { +res << vproto.pack_bool_field(o.disable_embed_inlining, 23) +} + +if o.has_sign_into_friends { +res << vproto.pack_bool_field(o.sign_into_friends, 24) +} + +if o.has_animated_avatars { +res << vproto.pack_bool_field(o.animated_avatars, 25) +} + +return res +} + +pub fn cchatusabilityclientusabilitymetricsnotificationsettings_unpack(buf []byte) ?CChatUsabilityClientUsabilityMetricsNotificationSettings { +mut res := CChatUsabilityClientUsabilityMetricsNotificationSettings{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_notifications_show_ingame = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.notifications_show_ingame = v +i = ii +} + +2 { +res.has_notifications_show_online = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.notifications_show_online = v +i = ii +} + +3 { +res.has_notifications_show_message = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.notifications_show_message = v +i = ii +} + +4 { +res.has_notifications_events_and_announcements = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.notifications_events_and_announcements = v +i = ii +} + +5 { +res.has_sounds_play_ingame = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.sounds_play_ingame = v +i = ii +} + +6 { +res.has_sounds_play_online = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.sounds_play_online = v +i = ii +} + +7 { +res.has_sounds_play_message = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.sounds_play_message = v +i = ii +} + +8 { +res.has_sounds_events_and_announcements = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.sounds_events_and_announcements = v +i = ii +} + +9 { +res.has_always_new_chat_window = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.always_new_chat_window = v +i = ii +} + +10 { +res.has_force_alphabetic_friend_sorting = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.force_alphabetic_friend_sorting = v +i = ii +} + +11 { +res.has_chat_flash_mode = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.chat_flash_mode = v +i = ii +} + +12 { +res.has_remember_open_chats = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.remember_open_chats = v +i = ii +} + +13 { +res.has_compact_quick_access = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.compact_quick_access = v +i = ii +} + +14 { +res.has_compact_friends_list = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.compact_friends_list = v +i = ii +} + +15 { +res.has_notifications_show_chat_room_notification = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.notifications_show_chat_room_notification = v +i = ii +} + +16 { +res.has_sounds_play_chat_room_notification = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.sounds_play_chat_room_notification = v +i = ii +} + +17 { +res.has_hide_offline_friends_in_tag_groups = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.hide_offline_friends_in_tag_groups = v +i = ii +} + +18 { +res.has_hide_categorized_friends = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.hide_categorized_friends = v +i = ii +} + +19 { +res.has_categorize_in_game_friends_by_game = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.categorize_in_game_friends_by_game = v +i = ii +} + +20 { +res.has_chat_font_size = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.chat_font_size = v +i = ii +} + +21 { +res.has_use24hour_clock = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.use24hour_clock = v +i = ii +} + +22 { +res.has_do_not_disturb_mode = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.do_not_disturb_mode = v +i = ii +} + +23 { +res.has_disable_embed_inlining = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.disable_embed_inlining = v +i = ii +} + +24 { +res.has_sign_into_friends = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.sign_into_friends = v +i = ii +} + +25 { +res.has_animated_avatars = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.animated_avatars = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatusabilityclientusabilitymetricsnotificationsettings() CChatUsabilityClientUsabilityMetricsNotificationSettings { +return CChatUsabilityClientUsabilityMetricsNotificationSettings{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatusabilityclientusabilitymetricsnotificationsettings(o CChatUsabilityClientUsabilityMetricsNotificationSettings, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatusabilityclientusabilitymetricsnotificationsettings(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatUsabilityClientUsabilityMetricsNotificationSettings) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatusabilityclientusabilitymetricsnotificationsettings_unpack(v)? +return i, unpacked +} +pub struct CChatUsabilityClientUsabilityMetricsNotificationVoiceSettings { +mut: +unknown_fields []vproto.UnknownField +pub mut: +voice_input_gain f32 +has_voice_input_gain bool +voice_output_gain f32 +has_voice_output_gain bool +noise_gate_level int +has_noise_gate_level bool +voice_use_echo_cancellation bool +has_voice_use_echo_cancellation bool +voice_use_noise_cancellation bool +has_voice_use_noise_cancellation bool +voice_use_auto_gain_control bool +has_voice_use_auto_gain_control bool +selected_non_default_mic bool +has_selected_non_default_mic bool +selected_non_default_output bool +has_selected_non_default_output bool +push_to_talk_enabled bool +has_push_to_talk_enabled bool +push_to_mute_enabled bool +has_push_to_mute_enabled bool +play_ptt_sounds bool +has_play_ptt_sounds bool +} +pub fn (o &CChatUsabilityClientUsabilityMetricsNotificationVoiceSettings) pack() []byte { +mut res := []byte{} +if o.has_voice_input_gain { +res << vproto.pack_float_field(o.voice_input_gain, 1) +} + +if o.has_voice_output_gain { +res << vproto.pack_float_field(o.voice_output_gain, 2) +} + +if o.has_noise_gate_level { +res << vproto.pack_int32_field(o.noise_gate_level, 3) +} + +if o.has_voice_use_echo_cancellation { +res << vproto.pack_bool_field(o.voice_use_echo_cancellation, 4) +} + +if o.has_voice_use_noise_cancellation { +res << vproto.pack_bool_field(o.voice_use_noise_cancellation, 5) +} + +if o.has_voice_use_auto_gain_control { +res << vproto.pack_bool_field(o.voice_use_auto_gain_control, 6) +} + +if o.has_selected_non_default_mic { +res << vproto.pack_bool_field(o.selected_non_default_mic, 7) +} + +if o.has_selected_non_default_output { +res << vproto.pack_bool_field(o.selected_non_default_output, 8) +} + +if o.has_push_to_talk_enabled { +res << vproto.pack_bool_field(o.push_to_talk_enabled, 9) +} + +if o.has_push_to_mute_enabled { +res << vproto.pack_bool_field(o.push_to_mute_enabled, 10) +} + +if o.has_play_ptt_sounds { +res << vproto.pack_bool_field(o.play_ptt_sounds, 11) +} + +return res +} + +pub fn cchatusabilityclientusabilitymetricsnotificationvoicesettings_unpack(buf []byte) ?CChatUsabilityClientUsabilityMetricsNotificationVoiceSettings { +mut res := CChatUsabilityClientUsabilityMetricsNotificationVoiceSettings{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_voice_input_gain = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.voice_input_gain = v +i = ii +} + +2 { +res.has_voice_output_gain = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.voice_output_gain = v +i = ii +} + +3 { +res.has_noise_gate_level = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.noise_gate_level = v +i = ii +} + +4 { +res.has_voice_use_echo_cancellation = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.voice_use_echo_cancellation = v +i = ii +} + +5 { +res.has_voice_use_noise_cancellation = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.voice_use_noise_cancellation = v +i = ii +} + +6 { +res.has_voice_use_auto_gain_control = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.voice_use_auto_gain_control = v +i = ii +} + +7 { +res.has_selected_non_default_mic = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.selected_non_default_mic = v +i = ii +} + +8 { +res.has_selected_non_default_output = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.selected_non_default_output = v +i = ii +} + +9 { +res.has_push_to_talk_enabled = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.push_to_talk_enabled = v +i = ii +} + +10 { +res.has_push_to_mute_enabled = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.push_to_mute_enabled = v +i = ii +} + +11 { +res.has_play_ptt_sounds = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.play_ptt_sounds = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatusabilityclientusabilitymetricsnotificationvoicesettings() CChatUsabilityClientUsabilityMetricsNotificationVoiceSettings { +return CChatUsabilityClientUsabilityMetricsNotificationVoiceSettings{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatusabilityclientusabilitymetricsnotificationvoicesettings(o CChatUsabilityClientUsabilityMetricsNotificationVoiceSettings, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatusabilityclientusabilitymetricsnotificationvoicesettings(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatUsabilityClientUsabilityMetricsNotificationVoiceSettings) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatusabilityclientusabilitymetricsnotificationvoicesettings_unpack(v)? +return i, unpacked +} +pub struct CChatUsabilityClientUsabilityMetricsNotificationUIstateCategoryCollapseState { +mut: +unknown_fields []vproto.UnknownField +pub mut: +in_game_collapsed bool +has_in_game_collapsed bool +online_collapsed bool +has_online_collapsed bool +offline_collapsed bool +has_offline_collapsed bool +game_groups_collapsed int +has_game_groups_collapsed bool +categories_collapsed int +has_categories_collapsed bool +} +pub fn (o &CChatUsabilityClientUsabilityMetricsNotificationUIstateCategoryCollapseState) pack() []byte { +mut res := []byte{} +if o.has_in_game_collapsed { +res << vproto.pack_bool_field(o.in_game_collapsed, 1) +} + +if o.has_online_collapsed { +res << vproto.pack_bool_field(o.online_collapsed, 2) +} + +if o.has_offline_collapsed { +res << vproto.pack_bool_field(o.offline_collapsed, 3) +} + +if o.has_game_groups_collapsed { +res << vproto.pack_int32_field(o.game_groups_collapsed, 4) +} + +if o.has_categories_collapsed { +res << vproto.pack_int32_field(o.categories_collapsed, 5) +} + +return res +} + +pub fn cchatusabilityclientusabilitymetricsnotificationuistatecategorycollapsestate_unpack(buf []byte) ?CChatUsabilityClientUsabilityMetricsNotificationUIstateCategoryCollapseState { +mut res := CChatUsabilityClientUsabilityMetricsNotificationUIstateCategoryCollapseState{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_in_game_collapsed = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.in_game_collapsed = v +i = ii +} + +2 { +res.has_online_collapsed = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.online_collapsed = v +i = ii +} + +3 { +res.has_offline_collapsed = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.offline_collapsed = v +i = ii +} + +4 { +res.has_game_groups_collapsed = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.game_groups_collapsed = v +i = ii +} + +5 { +res.has_categories_collapsed = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.categories_collapsed = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatusabilityclientusabilitymetricsnotificationuistatecategorycollapsestate() CChatUsabilityClientUsabilityMetricsNotificationUIstateCategoryCollapseState { +return CChatUsabilityClientUsabilityMetricsNotificationUIstateCategoryCollapseState{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatusabilityclientusabilitymetricsnotificationuistatecategorycollapsestate(o CChatUsabilityClientUsabilityMetricsNotificationUIstateCategoryCollapseState, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatusabilityclientusabilitymetricsnotificationuistatecategorycollapsestate(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatUsabilityClientUsabilityMetricsNotificationUIstateCategoryCollapseState) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatusabilityclientusabilitymetricsnotificationuistatecategorycollapsestate_unpack(v)? +return i, unpacked +} +pub struct CChatUsabilityClientUsabilityMetricsNotificationUIstate { +mut: +unknown_fields []vproto.UnknownField +pub mut: +friends_list_height int +has_friends_list_height bool +friends_list_width int +has_friends_list_width bool +friends_list_docked bool +has_friends_list_docked bool +friends_list_collapsed bool +has_friends_list_collapsed bool +friends_list_group_chats_height int +has_friends_list_group_chats_height bool +friends_list_visible bool +has_friends_list_visible bool +chat_popups_opened int +has_chat_popups_opened bool +group_chat_tabs_opened int +has_group_chat_tabs_opened bool +friend_chat_tabs_opened int +has_friend_chat_tabs_opened bool +chat_window_width int +has_chat_window_width bool +chat_window_height int +has_chat_window_height bool +category_collapse CChatUsabilityClientUsabilityMetricsNotificationUIstateCategoryCollapseState +has_category_collapse bool +group_chat_left_col_collapsed int +has_group_chat_left_col_collapsed bool +group_chat_right_col_collapsed int +has_group_chat_right_col_collapsed bool +in_one_on_one_voice_chat bool +has_in_one_on_one_voice_chat bool +in_group_voice_chat bool +has_in_group_voice_chat bool +} +pub fn (o &CChatUsabilityClientUsabilityMetricsNotificationUIstate) pack() []byte { +mut res := []byte{} +if o.has_friends_list_height { +res << vproto.pack_int32_field(o.friends_list_height, 1) +} + +if o.has_friends_list_width { +res << vproto.pack_int32_field(o.friends_list_width, 2) +} + +if o.has_friends_list_docked { +res << vproto.pack_bool_field(o.friends_list_docked, 3) +} + +if o.has_friends_list_collapsed { +res << vproto.pack_bool_field(o.friends_list_collapsed, 4) +} + +if o.has_friends_list_group_chats_height { +res << vproto.pack_int32_field(o.friends_list_group_chats_height, 5) +} + +if o.has_friends_list_visible { +res << vproto.pack_bool_field(o.friends_list_visible, 6) +} + +if o.has_chat_popups_opened { +res << vproto.pack_int32_field(o.chat_popups_opened, 7) +} + +if o.has_group_chat_tabs_opened { +res << vproto.pack_int32_field(o.group_chat_tabs_opened, 8) +} + +if o.has_friend_chat_tabs_opened { +res << vproto.pack_int32_field(o.friend_chat_tabs_opened, 9) +} + +if o.has_chat_window_width { +res << vproto.pack_int32_field(o.chat_window_width, 10) +} + +if o.has_chat_window_height { +res << vproto.pack_int32_field(o.chat_window_height, 11) +} + +if o.has_category_collapse { +res << zzz_vproto_internal_pack_cchatusabilityclientusabilitymetricsnotificationuistatecategorycollapsestate(o.category_collapse, 12) +} + +if o.has_group_chat_left_col_collapsed { +res << vproto.pack_int32_field(o.group_chat_left_col_collapsed, 13) +} + +if o.has_group_chat_right_col_collapsed { +res << vproto.pack_int32_field(o.group_chat_right_col_collapsed, 14) +} + +if o.has_in_one_on_one_voice_chat { +res << vproto.pack_bool_field(o.in_one_on_one_voice_chat, 15) +} + +if o.has_in_group_voice_chat { +res << vproto.pack_bool_field(o.in_group_voice_chat, 16) +} + +return res +} + +pub fn cchatusabilityclientusabilitymetricsnotificationuistate_unpack(buf []byte) ?CChatUsabilityClientUsabilityMetricsNotificationUIstate { +mut res := CChatUsabilityClientUsabilityMetricsNotificationUIstate{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_friends_list_height = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.friends_list_height = v +i = ii +} + +2 { +res.has_friends_list_width = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.friends_list_width = v +i = ii +} + +3 { +res.has_friends_list_docked = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.friends_list_docked = v +i = ii +} + +4 { +res.has_friends_list_collapsed = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.friends_list_collapsed = v +i = ii +} + +5 { +res.has_friends_list_group_chats_height = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.friends_list_group_chats_height = v +i = ii +} + +6 { +res.has_friends_list_visible = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.friends_list_visible = v +i = ii +} + +7 { +res.has_chat_popups_opened = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.chat_popups_opened = v +i = ii +} + +8 { +res.has_group_chat_tabs_opened = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.group_chat_tabs_opened = v +i = ii +} + +9 { +res.has_friend_chat_tabs_opened = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.friend_chat_tabs_opened = v +i = ii +} + +10 { +res.has_chat_window_width = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.chat_window_width = v +i = ii +} + +11 { +res.has_chat_window_height = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.chat_window_height = v +i = ii +} + +12 { +res.has_category_collapse = true +ii, v := zzz_vproto_internal_unpack_cchatusabilityclientusabilitymetricsnotificationuistatecategorycollapsestate(cur_buf, tag_wiretype.wire_type)? +res.category_collapse = v +i = ii +} + +13 { +res.has_group_chat_left_col_collapsed = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.group_chat_left_col_collapsed = v +i = ii +} + +14 { +res.has_group_chat_right_col_collapsed = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.group_chat_right_col_collapsed = v +i = ii +} + +15 { +res.has_in_one_on_one_voice_chat = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.in_one_on_one_voice_chat = v +i = ii +} + +16 { +res.has_in_group_voice_chat = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.in_group_voice_chat = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatusabilityclientusabilitymetricsnotificationuistate() CChatUsabilityClientUsabilityMetricsNotificationUIstate { +return CChatUsabilityClientUsabilityMetricsNotificationUIstate{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatusabilityclientusabilitymetricsnotificationuistate(o CChatUsabilityClientUsabilityMetricsNotificationUIstate, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatusabilityclientusabilitymetricsnotificationuistate(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatUsabilityClientUsabilityMetricsNotificationUIstate) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatusabilityclientusabilitymetricsnotificationuistate_unpack(v)? +return i, unpacked +} +pub struct CChatUsabilityClientUsabilityMetricsNotificationMetrics { +mut: +unknown_fields []vproto.UnknownField +pub mut: +friends_count int +has_friends_count bool +friends_category_count int +has_friends_category_count bool +friends_categorized_count int +has_friends_categorized_count bool +friends_online_count int +has_friends_online_count bool +friends_in_game_count int +has_friends_in_game_count bool +friends_in_game_singleton_count int +has_friends_in_game_singleton_count bool +game_group_count int +has_game_group_count bool +friends_favorite_count int +has_friends_favorite_count bool +group_chat_count int +has_group_chat_count bool +group_chat_favorite_count int +has_group_chat_favorite_count bool +} +pub fn (o &CChatUsabilityClientUsabilityMetricsNotificationMetrics) pack() []byte { +mut res := []byte{} +if o.has_friends_count { +res << vproto.pack_int32_field(o.friends_count, 1) +} + +if o.has_friends_category_count { +res << vproto.pack_int32_field(o.friends_category_count, 2) +} + +if o.has_friends_categorized_count { +res << vproto.pack_int32_field(o.friends_categorized_count, 3) +} + +if o.has_friends_online_count { +res << vproto.pack_int32_field(o.friends_online_count, 4) +} + +if o.has_friends_in_game_count { +res << vproto.pack_int32_field(o.friends_in_game_count, 5) +} + +if o.has_friends_in_game_singleton_count { +res << vproto.pack_int32_field(o.friends_in_game_singleton_count, 6) +} + +if o.has_game_group_count { +res << vproto.pack_int32_field(o.game_group_count, 7) +} + +if o.has_friends_favorite_count { +res << vproto.pack_int32_field(o.friends_favorite_count, 8) +} + +if o.has_group_chat_count { +res << vproto.pack_int32_field(o.group_chat_count, 9) +} + +if o.has_group_chat_favorite_count { +res << vproto.pack_int32_field(o.group_chat_favorite_count, 10) +} + +return res +} + +pub fn cchatusabilityclientusabilitymetricsnotificationmetrics_unpack(buf []byte) ?CChatUsabilityClientUsabilityMetricsNotificationMetrics { +mut res := CChatUsabilityClientUsabilityMetricsNotificationMetrics{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_friends_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.friends_count = v +i = ii +} + +2 { +res.has_friends_category_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.friends_category_count = v +i = ii +} + +3 { +res.has_friends_categorized_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.friends_categorized_count = v +i = ii +} + +4 { +res.has_friends_online_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.friends_online_count = v +i = ii +} + +5 { +res.has_friends_in_game_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.friends_in_game_count = v +i = ii +} + +6 { +res.has_friends_in_game_singleton_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.friends_in_game_singleton_count = v +i = ii +} + +7 { +res.has_game_group_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.game_group_count = v +i = ii +} + +8 { +res.has_friends_favorite_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.friends_favorite_count = v +i = ii +} + +9 { +res.has_group_chat_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.group_chat_count = v +i = ii +} + +10 { +res.has_group_chat_favorite_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.group_chat_favorite_count = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatusabilityclientusabilitymetricsnotificationmetrics() CChatUsabilityClientUsabilityMetricsNotificationMetrics { +return CChatUsabilityClientUsabilityMetricsNotificationMetrics{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatusabilityclientusabilitymetricsnotificationmetrics(o CChatUsabilityClientUsabilityMetricsNotificationMetrics, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatusabilityclientusabilitymetricsnotificationmetrics(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatUsabilityClientUsabilityMetricsNotificationMetrics) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatusabilityclientusabilitymetricsnotificationmetrics_unpack(v)? +return i, unpacked +} +pub struct CChatUsabilityClientUsabilityMetricsNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +metrics_run_id u32 +has_metrics_run_id bool +client_build u32 +has_client_build bool +metrics_version u32 +has_metrics_version bool +in_web bool +has_in_web bool +settings CChatUsabilityClientUsabilityMetricsNotificationSettings +has_settings bool +voice_settings CChatUsabilityClientUsabilityMetricsNotificationVoiceSettings +has_voice_settings bool +ui_state CChatUsabilityClientUsabilityMetricsNotificationUIstate +has_ui_state bool +metrics CChatUsabilityClientUsabilityMetricsNotificationMetrics +has_metrics bool +} +pub fn (o &CChatUsabilityClientUsabilityMetricsNotification) pack() []byte { +mut res := []byte{} +if o.has_metrics_run_id { +res << vproto.pack_uint32_field(o.metrics_run_id, 1) +} + +if o.has_client_build { +res << vproto.pack_uint32_field(o.client_build, 2) +} + +if o.has_metrics_version { +res << vproto.pack_uint32_field(o.metrics_version, 3) +} + +if o.has_in_web { +res << vproto.pack_bool_field(o.in_web, 4) +} + +if o.has_settings { +res << zzz_vproto_internal_pack_cchatusabilityclientusabilitymetricsnotificationsettings(o.settings, 10) +} + +if o.has_voice_settings { +res << zzz_vproto_internal_pack_cchatusabilityclientusabilitymetricsnotificationvoicesettings(o.voice_settings, 11) +} + +if o.has_ui_state { +res << zzz_vproto_internal_pack_cchatusabilityclientusabilitymetricsnotificationuistate(o.ui_state, 12) +} + +if o.has_metrics { +res << zzz_vproto_internal_pack_cchatusabilityclientusabilitymetricsnotificationmetrics(o.metrics, 13) +} + +return res +} + +pub fn cchatusabilityclientusabilitymetricsnotification_unpack(buf []byte) ?CChatUsabilityClientUsabilityMetricsNotification { +mut res := CChatUsabilityClientUsabilityMetricsNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_metrics_run_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.metrics_run_id = v +i = ii +} + +2 { +res.has_client_build = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.client_build = v +i = ii +} + +3 { +res.has_metrics_version = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.metrics_version = v +i = ii +} + +4 { +res.has_in_web = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.in_web = v +i = ii +} + +10 { +res.has_settings = true +ii, v := zzz_vproto_internal_unpack_cchatusabilityclientusabilitymetricsnotificationsettings(cur_buf, tag_wiretype.wire_type)? +res.settings = v +i = ii +} + +11 { +res.has_voice_settings = true +ii, v := zzz_vproto_internal_unpack_cchatusabilityclientusabilitymetricsnotificationvoicesettings(cur_buf, tag_wiretype.wire_type)? +res.voice_settings = v +i = ii +} + +12 { +res.has_ui_state = true +ii, v := zzz_vproto_internal_unpack_cchatusabilityclientusabilitymetricsnotificationuistate(cur_buf, tag_wiretype.wire_type)? +res.ui_state = v +i = ii +} + +13 { +res.has_metrics = true +ii, v := zzz_vproto_internal_unpack_cchatusabilityclientusabilitymetricsnotificationmetrics(cur_buf, tag_wiretype.wire_type)? +res.metrics = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatusabilityclientusabilitymetricsnotification() CChatUsabilityClientUsabilityMetricsNotification { +return CChatUsabilityClientUsabilityMetricsNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatusabilityclientusabilitymetricsnotification(o CChatUsabilityClientUsabilityMetricsNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatusabilityclientusabilitymetricsnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatUsabilityClientUsabilityMetricsNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatusabilityclientusabilitymetricsnotification_unpack(v)? +return i, unpacked +} +pub struct CChatUsabilityRequestClientUsabilityMetricsNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +metrics_run_id u32 +has_metrics_run_id bool +} +pub fn (o &CChatUsabilityRequestClientUsabilityMetricsNotification) pack() []byte { +mut res := []byte{} +if o.has_metrics_run_id { +res << vproto.pack_uint32_field(o.metrics_run_id, 1) +} + +return res +} + +pub fn cchatusabilityrequestclientusabilitymetricsnotification_unpack(buf []byte) ?CChatUsabilityRequestClientUsabilityMetricsNotification { +mut res := CChatUsabilityRequestClientUsabilityMetricsNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_metrics_run_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.metrics_run_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cchatusabilityrequestclientusabilitymetricsnotification() CChatUsabilityRequestClientUsabilityMetricsNotification { +return CChatUsabilityRequestClientUsabilityMetricsNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cchatusabilityrequestclientusabilitymetricsnotification(o CChatUsabilityRequestClientUsabilityMetricsNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cchatusabilityrequestclientusabilitymetricsnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CChatUsabilityRequestClientUsabilityMetricsNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cchatusabilityrequestclientusabilitymetricsnotification_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_clientlanp2p_pb.v b/proto/steammessages_clientlanp2p_pb.v new file mode 100644 index 0000000..2839f85 --- /dev/null +++ b/proto/steammessages_clientlanp2p_pb.v @@ -0,0 +1,317 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CMsgClientLAnp2PRequestChunksChunkKey { +mut: +unknown_fields []vproto.UnknownField +pub mut: +depot_id u32 +has_depot_id bool +sha []byte +has_sha bool +} +pub fn (o &CMsgClientLAnp2PRequestChunksChunkKey) pack() []byte { +mut res := []byte{} +if o.has_depot_id { +res << vproto.pack_uint32_field(o.depot_id, 1) +} + +if o.has_sha { +res << vproto.pack_bytes_field(o.sha, 2) +} + +return res +} + +pub fn cmsgclientlanp2prequestchunkschunkkey_unpack(buf []byte) ?CMsgClientLAnp2PRequestChunksChunkKey { +mut res := CMsgClientLAnp2PRequestChunksChunkKey{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_depot_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.depot_id = v +i = ii +} + +2 { +res.has_sha = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientlanp2prequestchunkschunkkey() CMsgClientLAnp2PRequestChunksChunkKey { +return CMsgClientLAnp2PRequestChunksChunkKey{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientlanp2prequestchunkschunkkey(o CMsgClientLAnp2PRequestChunksChunkKey, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientlanp2prequestchunkschunkkey(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientLAnp2PRequestChunksChunkKey) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientlanp2prequestchunkschunkkey_unpack(v)? +return i, unpacked +} +pub struct CMsgClientLAnp2PRequestChunks { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chunk_keys []CMsgClientLAnp2PRequestChunksChunkKey +} +pub fn (o &CMsgClientLAnp2PRequestChunks) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.chunk_keys { +res << zzz_vproto_internal_pack_cmsgclientlanp2prequestchunkschunkkey(x, 1) +} + +return res +} + +pub fn cmsgclientlanp2prequestchunks_unpack(buf []byte) ?CMsgClientLAnp2PRequestChunks { +mut res := CMsgClientLAnp2PRequestChunks{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientlanp2prequestchunkschunkkey(cur_buf, tag_wiretype.wire_type)? +res.chunk_keys << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientlanp2prequestchunks() CMsgClientLAnp2PRequestChunks { +return CMsgClientLAnp2PRequestChunks{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientlanp2prequestchunks(o CMsgClientLAnp2PRequestChunks, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientlanp2prequestchunks(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientLAnp2PRequestChunks) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientlanp2prequestchunks_unpack(v)? +return i, unpacked +} +pub struct CMsgClientLAnp2PRequestChunksResponseChunkData { +mut: +unknown_fields []vproto.UnknownField +pub mut: +result u32 +has_result bool +depot_id u32 +has_depot_id bool +sha []byte +has_sha bool +chunk_data []byte +has_chunk_data bool +encrypted bool +has_encrypted bool +compressed bool +has_compressed bool +} +pub fn (o &CMsgClientLAnp2PRequestChunksResponseChunkData) pack() []byte { +mut res := []byte{} +if o.has_result { +res << vproto.pack_uint32_field(o.result, 1) +} + +if o.has_depot_id { +res << vproto.pack_uint32_field(o.depot_id, 2) +} + +if o.has_sha { +res << vproto.pack_bytes_field(o.sha, 3) +} + +if o.has_chunk_data { +res << vproto.pack_bytes_field(o.chunk_data, 4) +} + +if o.has_encrypted { +res << vproto.pack_bool_field(o.encrypted, 5) +} + +if o.has_compressed { +res << vproto.pack_bool_field(o.compressed, 6) +} + +return res +} + +pub fn cmsgclientlanp2prequestchunksresponsechunkdata_unpack(buf []byte) ?CMsgClientLAnp2PRequestChunksResponseChunkData { +mut res := CMsgClientLAnp2PRequestChunksResponseChunkData{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_result = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.result = v +i = ii +} + +2 { +res.has_depot_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.depot_id = v +i = ii +} + +3 { +res.has_sha = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha = v +i = ii +} + +4 { +res.has_chunk_data = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.chunk_data = v +i = ii +} + +5 { +res.has_encrypted = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.encrypted = v +i = ii +} + +6 { +res.has_compressed = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.compressed = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientlanp2prequestchunksresponsechunkdata() CMsgClientLAnp2PRequestChunksResponseChunkData { +return CMsgClientLAnp2PRequestChunksResponseChunkData{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientlanp2prequestchunksresponsechunkdata(o CMsgClientLAnp2PRequestChunksResponseChunkData, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientlanp2prequestchunksresponsechunkdata(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientLAnp2PRequestChunksResponseChunkData) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientlanp2prequestchunksresponsechunkdata_unpack(v)? +return i, unpacked +} +pub struct CMsgClientLAnp2PRequestChunksResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +chunk_responses []CMsgClientLAnp2PRequestChunksResponseChunkData +} +pub fn (o &CMsgClientLAnp2PRequestChunksResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.chunk_responses { +res << zzz_vproto_internal_pack_cmsgclientlanp2prequestchunksresponsechunkdata(x, 1) +} + +return res +} + +pub fn cmsgclientlanp2prequestchunksresponse_unpack(buf []byte) ?CMsgClientLAnp2PRequestChunksResponse { +mut res := CMsgClientLAnp2PRequestChunksResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientlanp2prequestchunksresponsechunkdata(cur_buf, tag_wiretype.wire_type)? +res.chunk_responses << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientlanp2prequestchunksresponse() CMsgClientLAnp2PRequestChunksResponse { +return CMsgClientLAnp2PRequestChunksResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientlanp2prequestchunksresponse(o CMsgClientLAnp2PRequestChunksResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientlanp2prequestchunksresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientLAnp2PRequestChunksResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientlanp2prequestchunksresponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_clientmetrics.steamclient_pb.v b/proto/steammessages_clientmetrics.steamclient_pb.v new file mode 100644 index 0000000..44ddc90 --- /dev/null +++ b/proto/steammessages_clientmetrics.steamclient_pb.v @@ -0,0 +1,845 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +[_allow_multiple_values] +enum ESteamPipeWorkType { +k_esteampipeclientworktype_invalid = 0 +k_esteampipeclientworktype_stagefromchunkstores = 1 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_esteampipeworktype(e ESteamPipeWorkType, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_esteampipeworktype(buf []byte, tag_wiretype vproto.WireType) ?(int, ESteamPipeWorkType) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, ESteamPipeWorkType(v) +} +[_allow_multiple_values] +enum ESteamPipeOperationType { +k_esteampipeoperationtype_invalid = 0 +k_esteampipeoperationtype_decryptcpu = 1 +k_esteampipeoperationtype_diskread = 2 +k_esteampipeoperationtype_diskwrite = 3 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_esteampipeoperationtype(e ESteamPipeOperationType, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_esteampipeoperationtype(buf []byte, tag_wiretype vproto.WireType) ?(int, ESteamPipeOperationType) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, ESteamPipeOperationType(v) +} +pub struct CClientMetricsAppInterfaceCreation { +mut: +unknown_fields []vproto.UnknownField +pub mut: +raw_version string +has_raw_version bool +requested_interface_type string +has_requested_interface_type bool +} +pub fn (o &CClientMetricsAppInterfaceCreation) pack() []byte { +mut res := []byte{} +if o.has_raw_version { +res << vproto.pack_string_field(o.raw_version, 1) +} + +if o.has_requested_interface_type { +res << vproto.pack_string_field(o.requested_interface_type, 2) +} + +return res +} + +pub fn cclientmetricsappinterfacecreation_unpack(buf []byte) ?CClientMetricsAppInterfaceCreation { +mut res := CClientMetricsAppInterfaceCreation{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_raw_version = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.raw_version = v +i = ii +} + +2 { +res.has_requested_interface_type = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.requested_interface_type = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cclientmetricsappinterfacecreation() CClientMetricsAppInterfaceCreation { +return CClientMetricsAppInterfaceCreation{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cclientmetricsappinterfacecreation(o CClientMetricsAppInterfaceCreation, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cclientmetricsappinterfacecreation(buf []byte, tag_wiretype vproto.WireType) ?(int, CClientMetricsAppInterfaceCreation) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cclientmetricsappinterfacecreation_unpack(v)? +return i, unpacked +} +pub struct CClientMetricsAppInterfaceMethodCounts { +mut: +unknown_fields []vproto.UnknownField +pub mut: +interface_name string +has_interface_name bool +method_name string +has_method_name bool +call_count u32 +has_call_count bool +} +pub fn (o &CClientMetricsAppInterfaceMethodCounts) pack() []byte { +mut res := []byte{} +if o.has_interface_name { +res << vproto.pack_string_field(o.interface_name, 1) +} + +if o.has_method_name { +res << vproto.pack_string_field(o.method_name, 2) +} + +if o.has_call_count { +res << vproto.pack_uint32_field(o.call_count, 3) +} + +return res +} + +pub fn cclientmetricsappinterfacemethodcounts_unpack(buf []byte) ?CClientMetricsAppInterfaceMethodCounts { +mut res := CClientMetricsAppInterfaceMethodCounts{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_interface_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.interface_name = v +i = ii +} + +2 { +res.has_method_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.method_name = v +i = ii +} + +3 { +res.has_call_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.call_count = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cclientmetricsappinterfacemethodcounts() CClientMetricsAppInterfaceMethodCounts { +return CClientMetricsAppInterfaceMethodCounts{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cclientmetricsappinterfacemethodcounts(o CClientMetricsAppInterfaceMethodCounts, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cclientmetricsappinterfacemethodcounts(buf []byte, tag_wiretype vproto.WireType) ?(int, CClientMetricsAppInterfaceMethodCounts) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cclientmetricsappinterfacemethodcounts_unpack(v)? +return i, unpacked +} +pub struct CClientMetricsAppInterfaceStatsNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +game_id u64 +has_game_id bool +interfaces_created []CClientMetricsAppInterfaceCreation +methods_called []CClientMetricsAppInterfaceMethodCounts +session_length_seconds u32 +has_session_length_seconds bool +} +pub fn (o &CClientMetricsAppInterfaceStatsNotification) pack() []byte { +mut res := []byte{} +if o.has_game_id { +res << vproto.pack_uint64_field(o.game_id, 1) +} + +// [packed=false] +for _, x in o.interfaces_created { +res << zzz_vproto_internal_pack_cclientmetricsappinterfacecreation(x, 2) +} + +// [packed=false] +for _, x in o.methods_called { +res << zzz_vproto_internal_pack_cclientmetricsappinterfacemethodcounts(x, 3) +} + +if o.has_session_length_seconds { +res << vproto.pack_uint32_field(o.session_length_seconds, 4) +} + +return res +} + +pub fn cclientmetricsappinterfacestatsnotification_unpack(buf []byte) ?CClientMetricsAppInterfaceStatsNotification { +mut res := CClientMetricsAppInterfaceStatsNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_game_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.game_id = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cclientmetricsappinterfacecreation(cur_buf, tag_wiretype.wire_type)? +res.interfaces_created << v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cclientmetricsappinterfacemethodcounts(cur_buf, tag_wiretype.wire_type)? +res.methods_called << v +i = ii +} + +4 { +res.has_session_length_seconds = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.session_length_seconds = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cclientmetricsappinterfacestatsnotification() CClientMetricsAppInterfaceStatsNotification { +return CClientMetricsAppInterfaceStatsNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cclientmetricsappinterfacestatsnotification(o CClientMetricsAppInterfaceStatsNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cclientmetricsappinterfacestatsnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CClientMetricsAppInterfaceStatsNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cclientmetricsappinterfacestatsnotification_unpack(v)? +return i, unpacked +} +pub struct CClientMetricsIPv6ConnectivityResult { +mut: +unknown_fields []vproto.UnknownField +pub mut: +protocol_tested u32 +has_protocol_tested bool +connectivity_state u32 +has_connectivity_state bool +} +pub fn (o &CClientMetricsIPv6ConnectivityResult) pack() []byte { +mut res := []byte{} +if o.has_protocol_tested { +res << vproto.pack_uint32_field(o.protocol_tested, 1) +} + +if o.has_connectivity_state { +res << vproto.pack_uint32_field(o.connectivity_state, 2) +} + +return res +} + +pub fn cclientmetricsipv6connectivityresult_unpack(buf []byte) ?CClientMetricsIPv6ConnectivityResult { +mut res := CClientMetricsIPv6ConnectivityResult{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_protocol_tested = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.protocol_tested = v +i = ii +} + +2 { +res.has_connectivity_state = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.connectivity_state = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cclientmetricsipv6connectivityresult() CClientMetricsIPv6ConnectivityResult { +return CClientMetricsIPv6ConnectivityResult{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cclientmetricsipv6connectivityresult(o CClientMetricsIPv6ConnectivityResult, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cclientmetricsipv6connectivityresult(buf []byte, tag_wiretype vproto.WireType) ?(int, CClientMetricsIPv6ConnectivityResult) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cclientmetricsipv6connectivityresult_unpack(v)? +return i, unpacked +} +pub struct CClientMetricsIPv6ConnectivityNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +cell_id u32 +has_cell_id bool +results []CClientMetricsIPv6ConnectivityResult +private_ip_is_rfc6598 bool +has_private_ip_is_rfc6598 bool +} +pub fn (o &CClientMetricsIPv6ConnectivityNotification) pack() []byte { +mut res := []byte{} +if o.has_cell_id { +res << vproto.pack_uint32_field(o.cell_id, 1) +} + +// [packed=false] +for _, x in o.results { +res << zzz_vproto_internal_pack_cclientmetricsipv6connectivityresult(x, 2) +} + +if o.has_private_ip_is_rfc6598 { +res << vproto.pack_bool_field(o.private_ip_is_rfc6598, 3) +} + +return res +} + +pub fn cclientmetricsipv6connectivitynotification_unpack(buf []byte) ?CClientMetricsIPv6ConnectivityNotification { +mut res := CClientMetricsIPv6ConnectivityNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_cell_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cell_id = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cclientmetricsipv6connectivityresult(cur_buf, tag_wiretype.wire_type)? +res.results << v +i = ii +} + +3 { +res.has_private_ip_is_rfc6598 = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.private_ip_is_rfc6598 = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cclientmetricsipv6connectivitynotification() CClientMetricsIPv6ConnectivityNotification { +return CClientMetricsIPv6ConnectivityNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cclientmetricsipv6connectivitynotification(o CClientMetricsIPv6ConnectivityNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cclientmetricsipv6connectivitynotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CClientMetricsIPv6ConnectivityNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cclientmetricsipv6connectivitynotification_unpack(v)? +return i, unpacked +} +pub struct CClientMetricsSteamPipeWorkStatsOperation { +mut: +unknown_fields []vproto.UnknownField +pub mut: +@type ESteamPipeOperationType +has_type bool +num_ops u32 +has_num_ops bool +num_bytes u64 +has_num_bytes bool +busy_time_ms u64 +has_busy_time_ms bool +idle_time_ms u64 +has_idle_time_ms bool +sum_run_time_ms u64 +has_sum_run_time_ms bool +sum_wait_time_ms u64 +has_sum_wait_time_ms bool +} +pub fn (o &CClientMetricsSteamPipeWorkStatsOperation) pack() []byte { +mut res := []byte{} +if o.has_type { +res << zzz_vproto_internal_pack_esteampipeoperationtype(o.@type, 1) +} + +if o.has_num_ops { +res << vproto.pack_uint32_field(o.num_ops, 2) +} + +if o.has_num_bytes { +res << vproto.pack_uint64_field(o.num_bytes, 3) +} + +if o.has_busy_time_ms { +res << vproto.pack_uint64_field(o.busy_time_ms, 4) +} + +if o.has_idle_time_ms { +res << vproto.pack_uint64_field(o.idle_time_ms, 5) +} + +if o.has_sum_run_time_ms { +res << vproto.pack_uint64_field(o.sum_run_time_ms, 6) +} + +if o.has_sum_wait_time_ms { +res << vproto.pack_uint64_field(o.sum_wait_time_ms, 7) +} + +return res +} + +pub fn cclientmetricssteampipeworkstatsoperation_unpack(buf []byte) ?CClientMetricsSteamPipeWorkStatsOperation { +mut res := CClientMetricsSteamPipeWorkStatsOperation{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_type = true +ii, v := zzz_vproto_internal_unpack_esteampipeoperationtype(cur_buf, tag_wiretype.wire_type)? +res.@type = v +i = ii +} + +2 { +res.has_num_ops = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.num_ops = v +i = ii +} + +3 { +res.has_num_bytes = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.num_bytes = v +i = ii +} + +4 { +res.has_busy_time_ms = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.busy_time_ms = v +i = ii +} + +5 { +res.has_idle_time_ms = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.idle_time_ms = v +i = ii +} + +6 { +res.has_sum_run_time_ms = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.sum_run_time_ms = v +i = ii +} + +7 { +res.has_sum_wait_time_ms = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.sum_wait_time_ms = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cclientmetricssteampipeworkstatsoperation() CClientMetricsSteamPipeWorkStatsOperation { +return CClientMetricsSteamPipeWorkStatsOperation{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cclientmetricssteampipeworkstatsoperation(o CClientMetricsSteamPipeWorkStatsOperation, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cclientmetricssteampipeworkstatsoperation(buf []byte, tag_wiretype vproto.WireType) ?(int, CClientMetricsSteamPipeWorkStatsOperation) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cclientmetricssteampipeworkstatsoperation_unpack(v)? +return i, unpacked +} +pub struct CClientMetricsSteamPipeWorkStatsNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +depotid u32 +has_depotid bool +work_type ESteamPipeWorkType +has_work_type bool +operations []CClientMetricsSteamPipeWorkStatsOperation +} +pub fn (o &CClientMetricsSteamPipeWorkStatsNotification) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_depotid { +res << vproto.pack_uint32_field(o.depotid, 2) +} + +if o.has_work_type { +res << zzz_vproto_internal_pack_esteampipeworktype(o.work_type, 3) +} + +// [packed=false] +for _, x in o.operations { +res << zzz_vproto_internal_pack_cclientmetricssteampipeworkstatsoperation(x, 4) +} + +return res +} + +pub fn cclientmetricssteampipeworkstatsnotification_unpack(buf []byte) ?CClientMetricsSteamPipeWorkStatsNotification { +mut res := CClientMetricsSteamPipeWorkStatsNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_depotid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.depotid = v +i = ii +} + +3 { +res.has_work_type = true +ii, v := zzz_vproto_internal_unpack_esteampipeworktype(cur_buf, tag_wiretype.wire_type)? +res.work_type = v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cclientmetricssteampipeworkstatsoperation(cur_buf, tag_wiretype.wire_type)? +res.operations << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cclientmetricssteampipeworkstatsnotification() CClientMetricsSteamPipeWorkStatsNotification { +return CClientMetricsSteamPipeWorkStatsNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cclientmetricssteampipeworkstatsnotification(o CClientMetricsSteamPipeWorkStatsNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cclientmetricssteampipeworkstatsnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CClientMetricsSteamPipeWorkStatsNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cclientmetricssteampipeworkstatsnotification_unpack(v)? +return i, unpacked +} +pub struct CClientMetricsReportClientErrorNotificationError { +mut: +unknown_fields []vproto.UnknownField +pub mut: +identifier string +has_identifier bool +message string +has_message bool +count u32 +has_count bool +} +pub fn (o &CClientMetricsReportClientErrorNotificationError) pack() []byte { +mut res := []byte{} +if o.has_identifier { +res << vproto.pack_string_field(o.identifier, 1) +} + +if o.has_message { +res << vproto.pack_string_field(o.message, 2) +} + +if o.has_count { +res << vproto.pack_uint32_field(o.count, 3) +} + +return res +} + +pub fn cclientmetricsreportclienterrornotificationerror_unpack(buf []byte) ?CClientMetricsReportClientErrorNotificationError { +mut res := CClientMetricsReportClientErrorNotificationError{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_identifier = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.identifier = v +i = ii +} + +2 { +res.has_message = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.message = v +i = ii +} + +3 { +res.has_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.count = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cclientmetricsreportclienterrornotificationerror() CClientMetricsReportClientErrorNotificationError { +return CClientMetricsReportClientErrorNotificationError{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cclientmetricsreportclienterrornotificationerror(o CClientMetricsReportClientErrorNotificationError, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cclientmetricsreportclienterrornotificationerror(buf []byte, tag_wiretype vproto.WireType) ?(int, CClientMetricsReportClientErrorNotificationError) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cclientmetricsreportclienterrornotificationerror_unpack(v)? +return i, unpacked +} +pub struct CClientMetricsReportClientErrorNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +product string +has_product bool +version string +has_version bool +errors []CClientMetricsReportClientErrorNotificationError +} +pub fn (o &CClientMetricsReportClientErrorNotification) pack() []byte { +mut res := []byte{} +if o.has_product { +res << vproto.pack_string_field(o.product, 1) +} + +if o.has_version { +res << vproto.pack_string_field(o.version, 2) +} + +// [packed=false] +for _, x in o.errors { +res << zzz_vproto_internal_pack_cclientmetricsreportclienterrornotificationerror(x, 3) +} + +return res +} + +pub fn cclientmetricsreportclienterrornotification_unpack(buf []byte) ?CClientMetricsReportClientErrorNotification { +mut res := CClientMetricsReportClientErrorNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_product = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.product = v +i = ii +} + +2 { +res.has_version = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.version = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cclientmetricsreportclienterrornotificationerror(cur_buf, tag_wiretype.wire_type)? +res.errors << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cclientmetricsreportclienterrornotification() CClientMetricsReportClientErrorNotification { +return CClientMetricsReportClientErrorNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cclientmetricsreportclienterrornotification(o CClientMetricsReportClientErrorNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cclientmetricsreportclienterrornotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CClientMetricsReportClientErrorNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cclientmetricsreportclienterrornotification_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_clientserver_2_pb.v b/proto/steammessages_clientserver_2_pb.v new file mode 100644 index 0000000..81f6034 --- /dev/null +++ b/proto/steammessages_clientserver_2_pb.v @@ -0,0 +1,15749 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CMsgClientUCmaddScreenshotTag { +mut: +unknown_fields []vproto.UnknownField +pub mut: +tag_name string +has_tag_name bool +tag_value string +has_tag_value bool +} +pub fn (o &CMsgClientUCmaddScreenshotTag) pack() []byte { +mut res := []byte{} +if o.has_tag_name { +res << vproto.pack_string_field(o.tag_name, 1) +} + +if o.has_tag_value { +res << vproto.pack_string_field(o.tag_value, 2) +} + +return res +} + +pub fn cmsgclientucmaddscreenshottag_unpack(buf []byte) ?CMsgClientUCmaddScreenshotTag { +mut res := CMsgClientUCmaddScreenshotTag{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_tag_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.tag_name = v +i = ii +} + +2 { +res.has_tag_value = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.tag_value = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmaddscreenshottag() CMsgClientUCmaddScreenshotTag { +return CMsgClientUCmaddScreenshotTag{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmaddscreenshottag(o CMsgClientUCmaddScreenshotTag, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmaddscreenshottag(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmaddScreenshotTag) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmaddscreenshottag_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmaddScreenshot { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +filename string +has_filename bool +thumbname string +has_thumbname bool +vr_filename string +has_vr_filename bool +rtime32_created u32 +has_rtime32_created bool +width u32 +has_width bool +height u32 +has_height bool +permissions u32 +has_permissions bool +caption string +has_caption bool +shortcut_name string +has_shortcut_name bool +tag []CMsgClientUCmaddScreenshotTag +tagged_steamid []u64 +spoiler_tag bool +has_spoiler_tag bool +tagged_publishedfileid []u64 +} +pub fn (o &CMsgClientUCmaddScreenshot) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_filename { +res << vproto.pack_string_field(o.filename, 2) +} + +if o.has_thumbname { +res << vproto.pack_string_field(o.thumbname, 3) +} + +if o.has_vr_filename { +res << vproto.pack_string_field(o.vr_filename, 14) +} + +if o.has_rtime32_created { +res << vproto.pack_32bit_field(o.rtime32_created, 4) +} + +if o.has_width { +res << vproto.pack_uint32_field(o.width, 5) +} + +if o.has_height { +res << vproto.pack_uint32_field(o.height, 6) +} + +if o.has_permissions { +res << vproto.pack_uint32_field(o.permissions, 7) +} + +if o.has_caption { +res << vproto.pack_string_field(o.caption, 8) +} + +if o.has_shortcut_name { +res << vproto.pack_string_field(o.shortcut_name, 9) +} + +// [packed=false] +for _, x in o.tag { +res << zzz_vproto_internal_pack_cmsgclientucmaddscreenshottag(x, 10) +} + +// [packed=false] +for _, x in o.tagged_steamid { +res << vproto.pack_64bit_field(x, 11) +} + +if o.has_spoiler_tag { +res << vproto.pack_bool_field(o.spoiler_tag, 12) +} + +// [packed=false] +for _, x in o.tagged_publishedfileid { +res << vproto.pack_uint64_field(x, 13) +} + +return res +} + +pub fn cmsgclientucmaddscreenshot_unpack(buf []byte) ?CMsgClientUCmaddScreenshot { +mut res := CMsgClientUCmaddScreenshot{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.filename = v +i = ii +} + +3 { +res.has_thumbname = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.thumbname = v +i = ii +} + +14 { +res.has_vr_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.vr_filename = v +i = ii +} + +4 { +res.has_rtime32_created = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.rtime32_created = v +i = ii +} + +5 { +res.has_width = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.width = v +i = ii +} + +6 { +res.has_height = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.height = v +i = ii +} + +7 { +res.has_permissions = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.permissions = v +i = ii +} + +8 { +res.has_caption = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.caption = v +i = ii +} + +9 { +res.has_shortcut_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.shortcut_name = v +i = ii +} + +10 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientucmaddscreenshottag(cur_buf, tag_wiretype.wire_type)? +res.tag << v +i = ii +} + +11 { +// [packed=false] +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.tagged_steamid << v +i = ii +} + +12 { +res.has_spoiler_tag = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.spoiler_tag = v +i = ii +} + +13 { +// [packed=false] +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.tagged_publishedfileid << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmaddscreenshot() CMsgClientUCmaddScreenshot { +return CMsgClientUCmaddScreenshot{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmaddscreenshot(o CMsgClientUCmaddScreenshot, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmaddscreenshot(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmaddScreenshot) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmaddscreenshot_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmaddScreenshotResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +screenshotid u64 +has_screenshotid bool +} +pub fn (o &CMsgClientUCmaddScreenshotResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_screenshotid { +res << vproto.pack_64bit_field(o.screenshotid, 2) +} + +return res +} + +pub fn cmsgclientucmaddscreenshotresponse_unpack(buf []byte) ?CMsgClientUCmaddScreenshotResponse { +mut res := CMsgClientUCmaddScreenshotResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_screenshotid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.screenshotid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmaddscreenshotresponse() CMsgClientUCmaddScreenshotResponse { +return CMsgClientUCmaddScreenshotResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmaddscreenshotresponse(o CMsgClientUCmaddScreenshotResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmaddscreenshotresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmaddScreenshotResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmaddscreenshotresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmdeleteScreenshot { +mut: +unknown_fields []vproto.UnknownField +pub mut: +screenshotid u64 +has_screenshotid bool +} +pub fn (o &CMsgClientUCmdeleteScreenshot) pack() []byte { +mut res := []byte{} +if o.has_screenshotid { +res << vproto.pack_64bit_field(o.screenshotid, 1) +} + +return res +} + +pub fn cmsgclientucmdeletescreenshot_unpack(buf []byte) ?CMsgClientUCmdeleteScreenshot { +mut res := CMsgClientUCmdeleteScreenshot{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_screenshotid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.screenshotid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmdeletescreenshot() CMsgClientUCmdeleteScreenshot { +return CMsgClientUCmdeleteScreenshot{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmdeletescreenshot(o CMsgClientUCmdeleteScreenshot, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmdeletescreenshot(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmdeleteScreenshot) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmdeletescreenshot_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmdeleteScreenshotResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +} +pub fn (o &CMsgClientUCmdeleteScreenshotResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +return res +} + +pub fn cmsgclientucmdeletescreenshotresponse_unpack(buf []byte) ?CMsgClientUCmdeleteScreenshotResponse { +mut res := CMsgClientUCmdeleteScreenshotResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmdeletescreenshotresponse() CMsgClientUCmdeleteScreenshotResponse { +return CMsgClientUCmdeleteScreenshotResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmdeletescreenshotresponse(o CMsgClientUCmdeleteScreenshotResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmdeletescreenshotresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmdeleteScreenshotResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmdeletescreenshotresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmpublishFile { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +file_name string +has_file_name bool +preview_file_name string +has_preview_file_name bool +consumer_app_id u32 +has_consumer_app_id bool +title string +has_title bool +description string +has_description bool +tags []string +workshop_file bool +has_workshop_file bool +visibility int +has_visibility bool +file_type u32 +has_file_type bool +url string +has_url bool +video_provider u32 +has_video_provider bool +video_account_name string +has_video_account_name bool +video_identifier string +has_video_identifier bool +in_progress bool +has_in_progress bool +} +pub fn (o &CMsgClientUCmpublishFile) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_file_name { +res << vproto.pack_string_field(o.file_name, 2) +} + +if o.has_preview_file_name { +res << vproto.pack_string_field(o.preview_file_name, 3) +} + +if o.has_consumer_app_id { +res << vproto.pack_uint32_field(o.consumer_app_id, 4) +} + +if o.has_title { +res << vproto.pack_string_field(o.title, 5) +} + +if o.has_description { +res << vproto.pack_string_field(o.description, 6) +} + +// [packed=false] +for _, x in o.tags { +res << vproto.pack_string_field(x, 8) +} + +if o.has_workshop_file { +res << vproto.pack_bool_field(o.workshop_file, 9) +} + +if o.has_visibility { +res << vproto.pack_int32_field(o.visibility, 10) +} + +if o.has_file_type { +res << vproto.pack_uint32_field(o.file_type, 11) +} + +if o.has_url { +res << vproto.pack_string_field(o.url, 12) +} + +if o.has_video_provider { +res << vproto.pack_uint32_field(o.video_provider, 13) +} + +if o.has_video_account_name { +res << vproto.pack_string_field(o.video_account_name, 14) +} + +if o.has_video_identifier { +res << vproto.pack_string_field(o.video_identifier, 15) +} + +if o.has_in_progress { +res << vproto.pack_bool_field(o.in_progress, 16) +} + +return res +} + +pub fn cmsgclientucmpublishfile_unpack(buf []byte) ?CMsgClientUCmpublishFile { +mut res := CMsgClientUCmpublishFile{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_file_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.file_name = v +i = ii +} + +3 { +res.has_preview_file_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.preview_file_name = v +i = ii +} + +4 { +res.has_consumer_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.consumer_app_id = v +i = ii +} + +5 { +res.has_title = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.title = v +i = ii +} + +6 { +res.has_description = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.description = v +i = ii +} + +8 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.tags << v +i = ii +} + +9 { +res.has_workshop_file = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.workshop_file = v +i = ii +} + +10 { +res.has_visibility = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.visibility = v +i = ii +} + +11 { +res.has_file_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.file_type = v +i = ii +} + +12 { +res.has_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url = v +i = ii +} + +13 { +res.has_video_provider = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.video_provider = v +i = ii +} + +14 { +res.has_video_account_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.video_account_name = v +i = ii +} + +15 { +res.has_video_identifier = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.video_identifier = v +i = ii +} + +16 { +res.has_in_progress = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.in_progress = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmpublishfile() CMsgClientUCmpublishFile { +return CMsgClientUCmpublishFile{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmpublishfile(o CMsgClientUCmpublishFile, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmpublishfile(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmpublishFile) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmpublishfile_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmpublishFileResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +published_file_id u64 +has_published_file_id bool +needs_workshop_legal_agreement_acceptance bool +has_needs_workshop_legal_agreement_acceptance bool +} +pub fn (o &CMsgClientUCmpublishFileResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_published_file_id { +res << vproto.pack_64bit_field(o.published_file_id, 2) +} + +if o.has_needs_workshop_legal_agreement_acceptance { +res << vproto.pack_bool_field(o.needs_workshop_legal_agreement_acceptance, 3) +} + +return res +} + +pub fn cmsgclientucmpublishfileresponse_unpack(buf []byte) ?CMsgClientUCmpublishFileResponse { +mut res := CMsgClientUCmpublishFileResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_published_file_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.published_file_id = v +i = ii +} + +3 { +res.has_needs_workshop_legal_agreement_acceptance = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.needs_workshop_legal_agreement_acceptance = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmpublishfileresponse() CMsgClientUCmpublishFileResponse { +return CMsgClientUCmpublishFileResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmpublishfileresponse(o CMsgClientUCmpublishFileResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmpublishfileresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmpublishFileResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmpublishfileresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmupdatePublishedFileKeyValueTag { +mut: +unknown_fields []vproto.UnknownField +pub mut: +key string +has_key bool +value string +has_value bool +} +pub fn (o &CMsgClientUCmupdatePublishedFileKeyValueTag) pack() []byte { +mut res := []byte{} +if o.has_key { +res << vproto.pack_string_field(o.key, 1) +} + +if o.has_value { +res << vproto.pack_string_field(o.value, 2) +} + +return res +} + +pub fn cmsgclientucmupdatepublishedfilekeyvaluetag_unpack(buf []byte) ?CMsgClientUCmupdatePublishedFileKeyValueTag { +mut res := CMsgClientUCmupdatePublishedFileKeyValueTag{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_key = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.key = v +i = ii +} + +2 { +res.has_value = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.value = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmupdatepublishedfilekeyvaluetag() CMsgClientUCmupdatePublishedFileKeyValueTag { +return CMsgClientUCmupdatePublishedFileKeyValueTag{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmupdatepublishedfilekeyvaluetag(o CMsgClientUCmupdatePublishedFileKeyValueTag, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmupdatepublishedfilekeyvaluetag(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmupdatePublishedFileKeyValueTag) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmupdatepublishedfilekeyvaluetag_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmupdatePublishedFileAdditionalPreview { +mut: +unknown_fields []vproto.UnknownField +pub mut: +original_file_name string +has_original_file_name bool +internal_file_name string +has_internal_file_name bool +videoid string +has_videoid bool +preview_type u32 +has_preview_type bool +update_index int +has_update_index bool +} +pub fn (o &CMsgClientUCmupdatePublishedFileAdditionalPreview) pack() []byte { +mut res := []byte{} +if o.has_original_file_name { +res << vproto.pack_string_field(o.original_file_name, 1) +} + +if o.has_internal_file_name { +res << vproto.pack_string_field(o.internal_file_name, 2) +} + +if o.has_videoid { +res << vproto.pack_string_field(o.videoid, 3) +} + +if o.has_preview_type { +res << vproto.pack_uint32_field(o.preview_type, 4) +} + +if o.has_update_index { +res << vproto.pack_int32_field(o.update_index, 5) +} + +return res +} + +pub fn cmsgclientucmupdatepublishedfileadditionalpreview_unpack(buf []byte) ?CMsgClientUCmupdatePublishedFileAdditionalPreview { +mut res := CMsgClientUCmupdatePublishedFileAdditionalPreview{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_original_file_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.original_file_name = v +i = ii +} + +2 { +res.has_internal_file_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.internal_file_name = v +i = ii +} + +3 { +res.has_videoid = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.videoid = v +i = ii +} + +4 { +res.has_preview_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.preview_type = v +i = ii +} + +5 { +res.has_update_index = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.update_index = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmupdatepublishedfileadditionalpreview() CMsgClientUCmupdatePublishedFileAdditionalPreview { +return CMsgClientUCmupdatePublishedFileAdditionalPreview{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmupdatepublishedfileadditionalpreview(o CMsgClientUCmupdatePublishedFileAdditionalPreview, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmupdatepublishedfileadditionalpreview(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmupdatePublishedFileAdditionalPreview) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmupdatepublishedfileadditionalpreview_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmupdatePublishedFile { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +published_file_id u64 +has_published_file_id bool +file_name string +has_file_name bool +preview_file_name string +has_preview_file_name bool +title string +has_title bool +description string +has_description bool +tags []string +visibility int +has_visibility bool +update_file bool +has_update_file bool +update_preview_file bool +has_update_preview_file bool +update_title bool +has_update_title bool +update_description bool +has_update_description bool +update_tags bool +has_update_tags bool +update_visibility bool +has_update_visibility bool +change_description string +has_change_description bool +update_url bool +has_update_url bool +url string +has_url bool +update_content_manifest bool +has_update_content_manifest bool +content_manifest u64 +has_content_manifest bool +metadata string +has_metadata bool +update_metadata bool +has_update_metadata bool +language int +has_language bool +removed_kvtags []string +kvtags []CMsgClientUCmupdatePublishedFileKeyValueTag +previews []CMsgClientUCmupdatePublishedFileAdditionalPreview +previews_to_remove []int +clear_in_progress bool +has_clear_in_progress bool +remove_all_kvtags bool +has_remove_all_kvtags bool +} +pub fn (o &CMsgClientUCmupdatePublishedFile) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_published_file_id { +res << vproto.pack_64bit_field(o.published_file_id, 2) +} + +if o.has_file_name { +res << vproto.pack_string_field(o.file_name, 3) +} + +if o.has_preview_file_name { +res << vproto.pack_string_field(o.preview_file_name, 4) +} + +if o.has_title { +res << vproto.pack_string_field(o.title, 5) +} + +if o.has_description { +res << vproto.pack_string_field(o.description, 6) +} + +// [packed=false] +for _, x in o.tags { +res << vproto.pack_string_field(x, 7) +} + +if o.has_visibility { +res << vproto.pack_int32_field(o.visibility, 8) +} + +if o.has_update_file { +res << vproto.pack_bool_field(o.update_file, 9) +} + +if o.has_update_preview_file { +res << vproto.pack_bool_field(o.update_preview_file, 10) +} + +if o.has_update_title { +res << vproto.pack_bool_field(o.update_title, 11) +} + +if o.has_update_description { +res << vproto.pack_bool_field(o.update_description, 12) +} + +if o.has_update_tags { +res << vproto.pack_bool_field(o.update_tags, 13) +} + +if o.has_update_visibility { +res << vproto.pack_bool_field(o.update_visibility, 14) +} + +if o.has_change_description { +res << vproto.pack_string_field(o.change_description, 15) +} + +if o.has_update_url { +res << vproto.pack_bool_field(o.update_url, 16) +} + +if o.has_url { +res << vproto.pack_string_field(o.url, 17) +} + +if o.has_update_content_manifest { +res << vproto.pack_bool_field(o.update_content_manifest, 18) +} + +if o.has_content_manifest { +res << vproto.pack_64bit_field(o.content_manifest, 19) +} + +if o.has_metadata { +res << vproto.pack_string_field(o.metadata, 20) +} + +if o.has_update_metadata { +res << vproto.pack_bool_field(o.update_metadata, 21) +} + +if o.has_language { +res << vproto.pack_int32_field(o.language, 22) +} + +// [packed=false] +for _, x in o.removed_kvtags { +res << vproto.pack_string_field(x, 23) +} + +// [packed=false] +for _, x in o.kvtags { +res << zzz_vproto_internal_pack_cmsgclientucmupdatepublishedfilekeyvaluetag(x, 24) +} + +// [packed=false] +for _, x in o.previews { +res << zzz_vproto_internal_pack_cmsgclientucmupdatepublishedfileadditionalpreview(x, 25) +} + +// [packed=false] +for _, x in o.previews_to_remove { +res << vproto.pack_int32_field(x, 26) +} + +if o.has_clear_in_progress { +res << vproto.pack_bool_field(o.clear_in_progress, 27) +} + +if o.has_remove_all_kvtags { +res << vproto.pack_bool_field(o.remove_all_kvtags, 28) +} + +return res +} + +pub fn cmsgclientucmupdatepublishedfile_unpack(buf []byte) ?CMsgClientUCmupdatePublishedFile { +mut res := CMsgClientUCmupdatePublishedFile{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_published_file_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.published_file_id = v +i = ii +} + +3 { +res.has_file_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.file_name = v +i = ii +} + +4 { +res.has_preview_file_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.preview_file_name = v +i = ii +} + +5 { +res.has_title = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.title = v +i = ii +} + +6 { +res.has_description = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.description = v +i = ii +} + +7 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.tags << v +i = ii +} + +8 { +res.has_visibility = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.visibility = v +i = ii +} + +9 { +res.has_update_file = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.update_file = v +i = ii +} + +10 { +res.has_update_preview_file = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.update_preview_file = v +i = ii +} + +11 { +res.has_update_title = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.update_title = v +i = ii +} + +12 { +res.has_update_description = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.update_description = v +i = ii +} + +13 { +res.has_update_tags = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.update_tags = v +i = ii +} + +14 { +res.has_update_visibility = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.update_visibility = v +i = ii +} + +15 { +res.has_change_description = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.change_description = v +i = ii +} + +16 { +res.has_update_url = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.update_url = v +i = ii +} + +17 { +res.has_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url = v +i = ii +} + +18 { +res.has_update_content_manifest = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.update_content_manifest = v +i = ii +} + +19 { +res.has_content_manifest = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.content_manifest = v +i = ii +} + +20 { +res.has_metadata = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.metadata = v +i = ii +} + +21 { +res.has_update_metadata = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.update_metadata = v +i = ii +} + +22 { +res.has_language = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +23 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.removed_kvtags << v +i = ii +} + +24 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientucmupdatepublishedfilekeyvaluetag(cur_buf, tag_wiretype.wire_type)? +res.kvtags << v +i = ii +} + +25 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientucmupdatepublishedfileadditionalpreview(cur_buf, tag_wiretype.wire_type)? +res.previews << v +i = ii +} + +26 { +// [packed=false] +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.previews_to_remove << v +i = ii +} + +27 { +res.has_clear_in_progress = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.clear_in_progress = v +i = ii +} + +28 { +res.has_remove_all_kvtags = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.remove_all_kvtags = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmupdatepublishedfile() CMsgClientUCmupdatePublishedFile { +return CMsgClientUCmupdatePublishedFile{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmupdatepublishedfile(o CMsgClientUCmupdatePublishedFile, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmupdatepublishedfile(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmupdatePublishedFile) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmupdatepublishedfile_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmupdatePublishedFileResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +needs_workshop_legal_agreement_acceptance bool +has_needs_workshop_legal_agreement_acceptance bool +} +pub fn (o &CMsgClientUCmupdatePublishedFileResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_needs_workshop_legal_agreement_acceptance { +res << vproto.pack_bool_field(o.needs_workshop_legal_agreement_acceptance, 2) +} + +return res +} + +pub fn cmsgclientucmupdatepublishedfileresponse_unpack(buf []byte) ?CMsgClientUCmupdatePublishedFileResponse { +mut res := CMsgClientUCmupdatePublishedFileResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_needs_workshop_legal_agreement_acceptance = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.needs_workshop_legal_agreement_acceptance = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmupdatepublishedfileresponse() CMsgClientUCmupdatePublishedFileResponse { +return CMsgClientUCmupdatePublishedFileResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmupdatepublishedfileresponse(o CMsgClientUCmupdatePublishedFileResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmupdatepublishedfileresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmupdatePublishedFileResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmupdatepublishedfileresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmdeletePublishedFile { +mut: +unknown_fields []vproto.UnknownField +pub mut: +published_file_id u64 +has_published_file_id bool +app_id u32 +has_app_id bool +} +pub fn (o &CMsgClientUCmdeletePublishedFile) pack() []byte { +mut res := []byte{} +if o.has_published_file_id { +res << vproto.pack_64bit_field(o.published_file_id, 1) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 2) +} + +return res +} + +pub fn cmsgclientucmdeletepublishedfile_unpack(buf []byte) ?CMsgClientUCmdeletePublishedFile { +mut res := CMsgClientUCmdeletePublishedFile{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_published_file_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.published_file_id = v +i = ii +} + +2 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmdeletepublishedfile() CMsgClientUCmdeletePublishedFile { +return CMsgClientUCmdeletePublishedFile{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmdeletepublishedfile(o CMsgClientUCmdeletePublishedFile, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmdeletepublishedfile(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmdeletePublishedFile) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmdeletepublishedfile_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmdeletePublishedFileResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +} +pub fn (o &CMsgClientUCmdeletePublishedFileResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +return res +} + +pub fn cmsgclientucmdeletepublishedfileresponse_unpack(buf []byte) ?CMsgClientUCmdeletePublishedFileResponse { +mut res := CMsgClientUCmdeletePublishedFileResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmdeletepublishedfileresponse() CMsgClientUCmdeletePublishedFileResponse { +return CMsgClientUCmdeletePublishedFileResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmdeletepublishedfileresponse(o CMsgClientUCmdeletePublishedFileResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmdeletepublishedfileresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmdeletePublishedFileResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmdeletepublishedfileresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmenumerateUserPublishedFiles { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +start_index u32 +has_start_index bool +sort_order u32 +has_sort_order bool +} +pub fn (o &CMsgClientUCmenumerateUserPublishedFiles) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_start_index { +res << vproto.pack_uint32_field(o.start_index, 2) +} + +if o.has_sort_order { +res << vproto.pack_uint32_field(o.sort_order, 3) +} + +return res +} + +pub fn cmsgclientucmenumerateuserpublishedfiles_unpack(buf []byte) ?CMsgClientUCmenumerateUserPublishedFiles { +mut res := CMsgClientUCmenumerateUserPublishedFiles{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_start_index = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.start_index = v +i = ii +} + +3 { +res.has_sort_order = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.sort_order = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmenumerateuserpublishedfiles() CMsgClientUCmenumerateUserPublishedFiles { +return CMsgClientUCmenumerateUserPublishedFiles{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmenumerateuserpublishedfiles(o CMsgClientUCmenumerateUserPublishedFiles, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmenumerateuserpublishedfiles(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmenumerateUserPublishedFiles) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmenumerateuserpublishedfiles_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmenumerateUserPublishedFilesResponsePublishedFileId { +mut: +unknown_fields []vproto.UnknownField +pub mut: +published_file_id u64 +has_published_file_id bool +} +pub fn (o &CMsgClientUCmenumerateUserPublishedFilesResponsePublishedFileId) pack() []byte { +mut res := []byte{} +if o.has_published_file_id { +res << vproto.pack_64bit_field(o.published_file_id, 1) +} + +return res +} + +pub fn cmsgclientucmenumerateuserpublishedfilesresponsepublishedfileid_unpack(buf []byte) ?CMsgClientUCmenumerateUserPublishedFilesResponsePublishedFileId { +mut res := CMsgClientUCmenumerateUserPublishedFilesResponsePublishedFileId{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_published_file_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.published_file_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmenumerateuserpublishedfilesresponsepublishedfileid() CMsgClientUCmenumerateUserPublishedFilesResponsePublishedFileId { +return CMsgClientUCmenumerateUserPublishedFilesResponsePublishedFileId{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmenumerateuserpublishedfilesresponsepublishedfileid(o CMsgClientUCmenumerateUserPublishedFilesResponsePublishedFileId, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmenumerateuserpublishedfilesresponsepublishedfileid(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmenumerateUserPublishedFilesResponsePublishedFileId) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmenumerateuserpublishedfilesresponsepublishedfileid_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmenumerateUserPublishedFilesResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +published_files []CMsgClientUCmenumerateUserPublishedFilesResponsePublishedFileId +total_results u32 +has_total_results bool +} +pub fn (o &CMsgClientUCmenumerateUserPublishedFilesResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +// [packed=false] +for _, x in o.published_files { +res << zzz_vproto_internal_pack_cmsgclientucmenumerateuserpublishedfilesresponsepublishedfileid(x, 2) +} + +if o.has_total_results { +res << vproto.pack_uint32_field(o.total_results, 3) +} + +return res +} + +pub fn cmsgclientucmenumerateuserpublishedfilesresponse_unpack(buf []byte) ?CMsgClientUCmenumerateUserPublishedFilesResponse { +mut res := CMsgClientUCmenumerateUserPublishedFilesResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientucmenumerateuserpublishedfilesresponsepublishedfileid(cur_buf, tag_wiretype.wire_type)? +res.published_files << v +i = ii +} + +3 { +res.has_total_results = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.total_results = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmenumerateuserpublishedfilesresponse() CMsgClientUCmenumerateUserPublishedFilesResponse { +return CMsgClientUCmenumerateUserPublishedFilesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmenumerateuserpublishedfilesresponse(o CMsgClientUCmenumerateUserPublishedFilesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmenumerateuserpublishedfilesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmenumerateUserPublishedFilesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmenumerateuserpublishedfilesresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmenumerateUserSubscribedFiles { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +start_index u32 +has_start_index bool +list_type u32 +has_list_type bool +matching_file_type u32 +has_matching_file_type bool +count u32 +has_count bool +} +pub fn (o &CMsgClientUCmenumerateUserSubscribedFiles) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_start_index { +res << vproto.pack_uint32_field(o.start_index, 2) +} + +if o.has_list_type { +res << vproto.pack_uint32_field(o.list_type, 3) +} + +if o.has_matching_file_type { +res << vproto.pack_uint32_field(o.matching_file_type, 4) +} + +if o.has_count { +res << vproto.pack_uint32_field(o.count, 5) +} + +return res +} + +pub fn cmsgclientucmenumerateusersubscribedfiles_unpack(buf []byte) ?CMsgClientUCmenumerateUserSubscribedFiles { +mut res := CMsgClientUCmenumerateUserSubscribedFiles{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_start_index = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.start_index = v +i = ii +} + +3 { +res.has_list_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.list_type = v +i = ii +} + +4 { +res.has_matching_file_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.matching_file_type = v +i = ii +} + +5 { +res.has_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.count = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmenumerateusersubscribedfiles() CMsgClientUCmenumerateUserSubscribedFiles { +return CMsgClientUCmenumerateUserSubscribedFiles{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmenumerateusersubscribedfiles(o CMsgClientUCmenumerateUserSubscribedFiles, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmenumerateusersubscribedfiles(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmenumerateUserSubscribedFiles) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmenumerateusersubscribedfiles_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmenumerateUserSubscribedFilesResponsePublishedFileId { +mut: +unknown_fields []vproto.UnknownField +pub mut: +published_file_id u64 +has_published_file_id bool +rtime32_subscribed u32 +has_rtime32_subscribed bool +} +pub fn (o &CMsgClientUCmenumerateUserSubscribedFilesResponsePublishedFileId) pack() []byte { +mut res := []byte{} +if o.has_published_file_id { +res << vproto.pack_64bit_field(o.published_file_id, 1) +} + +if o.has_rtime32_subscribed { +res << vproto.pack_32bit_field(o.rtime32_subscribed, 2) +} + +return res +} + +pub fn cmsgclientucmenumerateusersubscribedfilesresponsepublishedfileid_unpack(buf []byte) ?CMsgClientUCmenumerateUserSubscribedFilesResponsePublishedFileId { +mut res := CMsgClientUCmenumerateUserSubscribedFilesResponsePublishedFileId{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_published_file_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.published_file_id = v +i = ii +} + +2 { +res.has_rtime32_subscribed = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.rtime32_subscribed = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmenumerateusersubscribedfilesresponsepublishedfileid() CMsgClientUCmenumerateUserSubscribedFilesResponsePublishedFileId { +return CMsgClientUCmenumerateUserSubscribedFilesResponsePublishedFileId{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmenumerateusersubscribedfilesresponsepublishedfileid(o CMsgClientUCmenumerateUserSubscribedFilesResponsePublishedFileId, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmenumerateusersubscribedfilesresponsepublishedfileid(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmenumerateUserSubscribedFilesResponsePublishedFileId) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmenumerateusersubscribedfilesresponsepublishedfileid_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmenumerateUserSubscribedFilesResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +subscribed_files []CMsgClientUCmenumerateUserSubscribedFilesResponsePublishedFileId +total_results u32 +has_total_results bool +} +pub fn (o &CMsgClientUCmenumerateUserSubscribedFilesResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +// [packed=false] +for _, x in o.subscribed_files { +res << zzz_vproto_internal_pack_cmsgclientucmenumerateusersubscribedfilesresponsepublishedfileid(x, 2) +} + +if o.has_total_results { +res << vproto.pack_uint32_field(o.total_results, 3) +} + +return res +} + +pub fn cmsgclientucmenumerateusersubscribedfilesresponse_unpack(buf []byte) ?CMsgClientUCmenumerateUserSubscribedFilesResponse { +mut res := CMsgClientUCmenumerateUserSubscribedFilesResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientucmenumerateusersubscribedfilesresponsepublishedfileid(cur_buf, tag_wiretype.wire_type)? +res.subscribed_files << v +i = ii +} + +3 { +res.has_total_results = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.total_results = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmenumerateusersubscribedfilesresponse() CMsgClientUCmenumerateUserSubscribedFilesResponse { +return CMsgClientUCmenumerateUserSubscribedFilesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmenumerateusersubscribedfilesresponse(o CMsgClientUCmenumerateUserSubscribedFilesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmenumerateusersubscribedfilesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmenumerateUserSubscribedFilesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmenumerateusersubscribedfilesresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmenumerateUserSubscribedFilesWithUpdates { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +start_index u32 +has_start_index bool +start_time u32 +has_start_time bool +desired_revision u32 +has_desired_revision bool +} +pub fn (o &CMsgClientUCmenumerateUserSubscribedFilesWithUpdates) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_start_index { +res << vproto.pack_uint32_field(o.start_index, 2) +} + +if o.has_start_time { +res << vproto.pack_32bit_field(o.start_time, 3) +} + +if o.has_desired_revision { +res << vproto.pack_uint32_field(o.desired_revision, 4) +} + +return res +} + +pub fn cmsgclientucmenumerateusersubscribedfileswithupdates_unpack(buf []byte) ?CMsgClientUCmenumerateUserSubscribedFilesWithUpdates { +mut res := CMsgClientUCmenumerateUserSubscribedFilesWithUpdates{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_start_index = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.start_index = v +i = ii +} + +3 { +res.has_start_time = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.start_time = v +i = ii +} + +4 { +res.has_desired_revision = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.desired_revision = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmenumerateusersubscribedfileswithupdates() CMsgClientUCmenumerateUserSubscribedFilesWithUpdates { +return CMsgClientUCmenumerateUserSubscribedFilesWithUpdates{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmenumerateusersubscribedfileswithupdates(o CMsgClientUCmenumerateUserSubscribedFilesWithUpdates, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmenumerateusersubscribedfileswithupdates(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmenumerateUserSubscribedFilesWithUpdates) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmenumerateusersubscribedfileswithupdates_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmenumerateUserSubscribedFilesWithUpdatesResponsePublishedFileId { +mut: +unknown_fields []vproto.UnknownField +pub mut: +published_file_id u64 +has_published_file_id bool +rtime32_subscribed u32 +has_rtime32_subscribed bool +appid u32 +has_appid bool +file_hcontent u64 +has_file_hcontent bool +file_size u32 +has_file_size bool +rtime32_last_updated u32 +has_rtime32_last_updated bool +is_depot_content bool +has_is_depot_content bool +} +pub fn (o &CMsgClientUCmenumerateUserSubscribedFilesWithUpdatesResponsePublishedFileId) pack() []byte { +mut res := []byte{} +if o.has_published_file_id { +res << vproto.pack_64bit_field(o.published_file_id, 1) +} + +if o.has_rtime32_subscribed { +res << vproto.pack_32bit_field(o.rtime32_subscribed, 2) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 3) +} + +if o.has_file_hcontent { +res << vproto.pack_64bit_field(o.file_hcontent, 4) +} + +if o.has_file_size { +res << vproto.pack_uint32_field(o.file_size, 5) +} + +if o.has_rtime32_last_updated { +res << vproto.pack_32bit_field(o.rtime32_last_updated, 6) +} + +if o.has_is_depot_content { +res << vproto.pack_bool_field(o.is_depot_content, 7) +} + +return res +} + +pub fn cmsgclientucmenumerateusersubscribedfileswithupdatesresponsepublishedfileid_unpack(buf []byte) ?CMsgClientUCmenumerateUserSubscribedFilesWithUpdatesResponsePublishedFileId { +mut res := CMsgClientUCmenumerateUserSubscribedFilesWithUpdatesResponsePublishedFileId{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_published_file_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.published_file_id = v +i = ii +} + +2 { +res.has_rtime32_subscribed = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.rtime32_subscribed = v +i = ii +} + +3 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +4 { +res.has_file_hcontent = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.file_hcontent = v +i = ii +} + +5 { +res.has_file_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.file_size = v +i = ii +} + +6 { +res.has_rtime32_last_updated = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.rtime32_last_updated = v +i = ii +} + +7 { +res.has_is_depot_content = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_depot_content = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmenumerateusersubscribedfileswithupdatesresponsepublishedfileid() CMsgClientUCmenumerateUserSubscribedFilesWithUpdatesResponsePublishedFileId { +return CMsgClientUCmenumerateUserSubscribedFilesWithUpdatesResponsePublishedFileId{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmenumerateusersubscribedfileswithupdatesresponsepublishedfileid(o CMsgClientUCmenumerateUserSubscribedFilesWithUpdatesResponsePublishedFileId, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmenumerateusersubscribedfileswithupdatesresponsepublishedfileid(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmenumerateUserSubscribedFilesWithUpdatesResponsePublishedFileId) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmenumerateusersubscribedfileswithupdatesresponsepublishedfileid_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmenumerateUserSubscribedFilesWithUpdatesResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +subscribed_files []CMsgClientUCmenumerateUserSubscribedFilesWithUpdatesResponsePublishedFileId +total_results u32 +has_total_results bool +} +pub fn (o &CMsgClientUCmenumerateUserSubscribedFilesWithUpdatesResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +// [packed=false] +for _, x in o.subscribed_files { +res << zzz_vproto_internal_pack_cmsgclientucmenumerateusersubscribedfileswithupdatesresponsepublishedfileid(x, 2) +} + +if o.has_total_results { +res << vproto.pack_uint32_field(o.total_results, 3) +} + +return res +} + +pub fn cmsgclientucmenumerateusersubscribedfileswithupdatesresponse_unpack(buf []byte) ?CMsgClientUCmenumerateUserSubscribedFilesWithUpdatesResponse { +mut res := CMsgClientUCmenumerateUserSubscribedFilesWithUpdatesResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientucmenumerateusersubscribedfileswithupdatesresponsepublishedfileid(cur_buf, tag_wiretype.wire_type)? +res.subscribed_files << v +i = ii +} + +3 { +res.has_total_results = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.total_results = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmenumerateusersubscribedfileswithupdatesresponse() CMsgClientUCmenumerateUserSubscribedFilesWithUpdatesResponse { +return CMsgClientUCmenumerateUserSubscribedFilesWithUpdatesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmenumerateusersubscribedfileswithupdatesresponse(o CMsgClientUCmenumerateUserSubscribedFilesWithUpdatesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmenumerateusersubscribedfileswithupdatesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmenumerateUserSubscribedFilesWithUpdatesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmenumerateusersubscribedfileswithupdatesresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmpublishedFileUpdated { +mut: +unknown_fields []vproto.UnknownField +pub mut: +published_file_id u64 +has_published_file_id bool +app_id u32 +has_app_id bool +time_updated u32 +has_time_updated bool +hcontent u64 +has_hcontent bool +file_size u32 +has_file_size bool +is_depot_content bool +has_is_depot_content bool +revision u32 +has_revision bool +} +pub fn (o &CMsgClientUCmpublishedFileUpdated) pack() []byte { +mut res := []byte{} +if o.has_published_file_id { +res << vproto.pack_64bit_field(o.published_file_id, 1) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 2) +} + +if o.has_time_updated { +res << vproto.pack_uint32_field(o.time_updated, 3) +} + +if o.has_hcontent { +res << vproto.pack_64bit_field(o.hcontent, 4) +} + +if o.has_file_size { +res << vproto.pack_32bit_field(o.file_size, 5) +} + +if o.has_is_depot_content { +res << vproto.pack_bool_field(o.is_depot_content, 6) +} + +if o.has_revision { +res << vproto.pack_uint32_field(o.revision, 7) +} + +return res +} + +pub fn cmsgclientucmpublishedfileupdated_unpack(buf []byte) ?CMsgClientUCmpublishedFileUpdated { +mut res := CMsgClientUCmpublishedFileUpdated{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_published_file_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.published_file_id = v +i = ii +} + +2 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +3 { +res.has_time_updated = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_updated = v +i = ii +} + +4 { +res.has_hcontent = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.hcontent = v +i = ii +} + +5 { +res.has_file_size = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.file_size = v +i = ii +} + +6 { +res.has_is_depot_content = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_depot_content = v +i = ii +} + +7 { +res.has_revision = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.revision = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmpublishedfileupdated() CMsgClientUCmpublishedFileUpdated { +return CMsgClientUCmpublishedFileUpdated{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmpublishedfileupdated(o CMsgClientUCmpublishedFileUpdated, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmpublishedfileupdated(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmpublishedFileUpdated) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmpublishedfileupdated_unpack(v)? +return i, unpacked +} +pub struct CMsgClientWorkshopItemChangesRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +last_time_updated u32 +has_last_time_updated bool +num_items_needed u32 +has_num_items_needed bool +} +pub fn (o &CMsgClientWorkshopItemChangesRequest) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_last_time_updated { +res << vproto.pack_uint32_field(o.last_time_updated, 2) +} + +if o.has_num_items_needed { +res << vproto.pack_uint32_field(o.num_items_needed, 3) +} + +return res +} + +pub fn cmsgclientworkshopitemchangesrequest_unpack(buf []byte) ?CMsgClientWorkshopItemChangesRequest { +mut res := CMsgClientWorkshopItemChangesRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_last_time_updated = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_time_updated = v +i = ii +} + +3 { +res.has_num_items_needed = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.num_items_needed = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientworkshopitemchangesrequest() CMsgClientWorkshopItemChangesRequest { +return CMsgClientWorkshopItemChangesRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientworkshopitemchangesrequest(o CMsgClientWorkshopItemChangesRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientworkshopitemchangesrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientWorkshopItemChangesRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientworkshopitemchangesrequest_unpack(v)? +return i, unpacked +} +pub struct CMsgClientWorkshopItemChangesResponseWorkshopItemInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +published_file_id u64 +has_published_file_id bool +time_updated u32 +has_time_updated bool +manifest_id u64 +has_manifest_id bool +} +pub fn (o &CMsgClientWorkshopItemChangesResponseWorkshopItemInfo) pack() []byte { +mut res := []byte{} +if o.has_published_file_id { +res << vproto.pack_64bit_field(o.published_file_id, 1) +} + +if o.has_time_updated { +res << vproto.pack_uint32_field(o.time_updated, 2) +} + +if o.has_manifest_id { +res << vproto.pack_64bit_field(o.manifest_id, 3) +} + +return res +} + +pub fn cmsgclientworkshopitemchangesresponseworkshopiteminfo_unpack(buf []byte) ?CMsgClientWorkshopItemChangesResponseWorkshopItemInfo { +mut res := CMsgClientWorkshopItemChangesResponseWorkshopItemInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_published_file_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.published_file_id = v +i = ii +} + +2 { +res.has_time_updated = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_updated = v +i = ii +} + +3 { +res.has_manifest_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.manifest_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientworkshopitemchangesresponseworkshopiteminfo() CMsgClientWorkshopItemChangesResponseWorkshopItemInfo { +return CMsgClientWorkshopItemChangesResponseWorkshopItemInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientworkshopitemchangesresponseworkshopiteminfo(o CMsgClientWorkshopItemChangesResponseWorkshopItemInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientworkshopitemchangesresponseworkshopiteminfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientWorkshopItemChangesResponseWorkshopItemInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientworkshopitemchangesresponseworkshopiteminfo_unpack(v)? +return i, unpacked +} +pub struct CMsgClientWorkshopItemChangesResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +update_time u32 +has_update_time bool +workshop_items []CMsgClientWorkshopItemChangesResponseWorkshopItemInfo +} +pub fn (o &CMsgClientWorkshopItemChangesResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_update_time { +res << vproto.pack_uint32_field(o.update_time, 2) +} + +// [packed=false] +for _, x in o.workshop_items { +res << zzz_vproto_internal_pack_cmsgclientworkshopitemchangesresponseworkshopiteminfo(x, 5) +} + +return res +} + +pub fn cmsgclientworkshopitemchangesresponse_unpack(buf []byte) ?CMsgClientWorkshopItemChangesResponse { +mut res := CMsgClientWorkshopItemChangesResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_update_time = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.update_time = v +i = ii +} + +5 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientworkshopitemchangesresponseworkshopiteminfo(cur_buf, tag_wiretype.wire_type)? +res.workshop_items << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientworkshopitemchangesresponse() CMsgClientWorkshopItemChangesResponse { +return CMsgClientWorkshopItemChangesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientworkshopitemchangesresponse(o CMsgClientWorkshopItemChangesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientworkshopitemchangesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientWorkshopItemChangesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientworkshopitemchangesresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientWorkshopItemInfoRequestWorkshopItem { +mut: +unknown_fields []vproto.UnknownField +pub mut: +published_file_id u64 +has_published_file_id bool +time_updated u32 +has_time_updated bool +} +pub fn (o &CMsgClientWorkshopItemInfoRequestWorkshopItem) pack() []byte { +mut res := []byte{} +if o.has_published_file_id { +res << vproto.pack_64bit_field(o.published_file_id, 1) +} + +if o.has_time_updated { +res << vproto.pack_uint32_field(o.time_updated, 2) +} + +return res +} + +pub fn cmsgclientworkshopiteminforequestworkshopitem_unpack(buf []byte) ?CMsgClientWorkshopItemInfoRequestWorkshopItem { +mut res := CMsgClientWorkshopItemInfoRequestWorkshopItem{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_published_file_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.published_file_id = v +i = ii +} + +2 { +res.has_time_updated = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_updated = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientworkshopiteminforequestworkshopitem() CMsgClientWorkshopItemInfoRequestWorkshopItem { +return CMsgClientWorkshopItemInfoRequestWorkshopItem{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientworkshopiteminforequestworkshopitem(o CMsgClientWorkshopItemInfoRequestWorkshopItem, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientworkshopiteminforequestworkshopitem(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientWorkshopItemInfoRequestWorkshopItem) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientworkshopiteminforequestworkshopitem_unpack(v)? +return i, unpacked +} +pub struct CMsgClientWorkshopItemInfoRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +last_time_updated u32 +has_last_time_updated bool +workshop_items []CMsgClientWorkshopItemInfoRequestWorkshopItem +} +pub fn (o &CMsgClientWorkshopItemInfoRequest) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_last_time_updated { +res << vproto.pack_uint32_field(o.last_time_updated, 2) +} + +// [packed=false] +for _, x in o.workshop_items { +res << zzz_vproto_internal_pack_cmsgclientworkshopiteminforequestworkshopitem(x, 3) +} + +return res +} + +pub fn cmsgclientworkshopiteminforequest_unpack(buf []byte) ?CMsgClientWorkshopItemInfoRequest { +mut res := CMsgClientWorkshopItemInfoRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_last_time_updated = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_time_updated = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientworkshopiteminforequestworkshopitem(cur_buf, tag_wiretype.wire_type)? +res.workshop_items << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientworkshopiteminforequest() CMsgClientWorkshopItemInfoRequest { +return CMsgClientWorkshopItemInfoRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientworkshopiteminforequest(o CMsgClientWorkshopItemInfoRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientworkshopiteminforequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientWorkshopItemInfoRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientworkshopiteminforequest_unpack(v)? +return i, unpacked +} +pub struct CMsgClientWorkshopItemInfoResponseWorkshopItemInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +published_file_id u64 +has_published_file_id bool +time_updated u32 +has_time_updated bool +manifest_id u64 +has_manifest_id bool +is_legacy bool +has_is_legacy bool +} +pub fn (o &CMsgClientWorkshopItemInfoResponseWorkshopItemInfo) pack() []byte { +mut res := []byte{} +if o.has_published_file_id { +res << vproto.pack_64bit_field(o.published_file_id, 1) +} + +if o.has_time_updated { +res << vproto.pack_uint32_field(o.time_updated, 2) +} + +if o.has_manifest_id { +res << vproto.pack_64bit_field(o.manifest_id, 3) +} + +if o.has_is_legacy { +res << vproto.pack_bool_field(o.is_legacy, 4) +} + +return res +} + +pub fn cmsgclientworkshopiteminforesponseworkshopiteminfo_unpack(buf []byte) ?CMsgClientWorkshopItemInfoResponseWorkshopItemInfo { +mut res := CMsgClientWorkshopItemInfoResponseWorkshopItemInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_published_file_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.published_file_id = v +i = ii +} + +2 { +res.has_time_updated = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_updated = v +i = ii +} + +3 { +res.has_manifest_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.manifest_id = v +i = ii +} + +4 { +res.has_is_legacy = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_legacy = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientworkshopiteminforesponseworkshopiteminfo() CMsgClientWorkshopItemInfoResponseWorkshopItemInfo { +return CMsgClientWorkshopItemInfoResponseWorkshopItemInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientworkshopiteminforesponseworkshopiteminfo(o CMsgClientWorkshopItemInfoResponseWorkshopItemInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientworkshopiteminforesponseworkshopiteminfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientWorkshopItemInfoResponseWorkshopItemInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientworkshopiteminforesponseworkshopiteminfo_unpack(v)? +return i, unpacked +} +pub struct CMsgClientWorkshopItemInfoResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +update_time u32 +has_update_time bool +workshop_items []CMsgClientWorkshopItemInfoResponseWorkshopItemInfo +private_items []u64 +} +pub fn (o &CMsgClientWorkshopItemInfoResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_update_time { +res << vproto.pack_uint32_field(o.update_time, 2) +} + +// [packed=false] +for _, x in o.workshop_items { +res << zzz_vproto_internal_pack_cmsgclientworkshopiteminforesponseworkshopiteminfo(x, 3) +} + +// [packed=false] +for _, x in o.private_items { +res << vproto.pack_64bit_field(x, 4) +} + +return res +} + +pub fn cmsgclientworkshopiteminforesponse_unpack(buf []byte) ?CMsgClientWorkshopItemInfoResponse { +mut res := CMsgClientWorkshopItemInfoResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_update_time = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.update_time = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientworkshopiteminforesponseworkshopiteminfo(cur_buf, tag_wiretype.wire_type)? +res.workshop_items << v +i = ii +} + +4 { +// [packed=false] +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.private_items << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientworkshopiteminforesponse() CMsgClientWorkshopItemInfoResponse { +return CMsgClientWorkshopItemInfoResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientworkshopiteminforesponse(o CMsgClientWorkshopItemInfoResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientworkshopiteminforesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientWorkshopItemInfoResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientworkshopiteminforesponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmgetPublishedFilesForUser { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +creator_steam_id u64 +has_creator_steam_id bool +required_tags []string +excluded_tags []string +start_index u32 +has_start_index bool +} +pub fn (o &CMsgClientUCmgetPublishedFilesForUser) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_creator_steam_id { +res << vproto.pack_64bit_field(o.creator_steam_id, 2) +} + +// [packed=false] +for _, x in o.required_tags { +res << vproto.pack_string_field(x, 3) +} + +// [packed=false] +for _, x in o.excluded_tags { +res << vproto.pack_string_field(x, 4) +} + +if o.has_start_index { +res << vproto.pack_uint32_field(o.start_index, 5) +} + +return res +} + +pub fn cmsgclientucmgetpublishedfilesforuser_unpack(buf []byte) ?CMsgClientUCmgetPublishedFilesForUser { +mut res := CMsgClientUCmgetPublishedFilesForUser{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_creator_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.creator_steam_id = v +i = ii +} + +3 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.required_tags << v +i = ii +} + +4 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.excluded_tags << v +i = ii +} + +5 { +res.has_start_index = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.start_index = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmgetpublishedfilesforuser() CMsgClientUCmgetPublishedFilesForUser { +return CMsgClientUCmgetPublishedFilesForUser{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmgetpublishedfilesforuser(o CMsgClientUCmgetPublishedFilesForUser, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmgetpublishedfilesforuser(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmgetPublishedFilesForUser) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmgetpublishedfilesforuser_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmgetPublishedFilesForUserResponsePublishedFileId { +mut: +unknown_fields []vproto.UnknownField +pub mut: +published_file_id u64 +has_published_file_id bool +} +pub fn (o &CMsgClientUCmgetPublishedFilesForUserResponsePublishedFileId) pack() []byte { +mut res := []byte{} +if o.has_published_file_id { +res << vproto.pack_64bit_field(o.published_file_id, 1) +} + +return res +} + +pub fn cmsgclientucmgetpublishedfilesforuserresponsepublishedfileid_unpack(buf []byte) ?CMsgClientUCmgetPublishedFilesForUserResponsePublishedFileId { +mut res := CMsgClientUCmgetPublishedFilesForUserResponsePublishedFileId{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_published_file_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.published_file_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmgetpublishedfilesforuserresponsepublishedfileid() CMsgClientUCmgetPublishedFilesForUserResponsePublishedFileId { +return CMsgClientUCmgetPublishedFilesForUserResponsePublishedFileId{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmgetpublishedfilesforuserresponsepublishedfileid(o CMsgClientUCmgetPublishedFilesForUserResponsePublishedFileId, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmgetpublishedfilesforuserresponsepublishedfileid(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmgetPublishedFilesForUserResponsePublishedFileId) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmgetpublishedfilesforuserresponsepublishedfileid_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmgetPublishedFilesForUserResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +published_files []CMsgClientUCmgetPublishedFilesForUserResponsePublishedFileId +total_results u32 +has_total_results bool +} +pub fn (o &CMsgClientUCmgetPublishedFilesForUserResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +// [packed=false] +for _, x in o.published_files { +res << zzz_vproto_internal_pack_cmsgclientucmgetpublishedfilesforuserresponsepublishedfileid(x, 2) +} + +if o.has_total_results { +res << vproto.pack_uint32_field(o.total_results, 3) +} + +return res +} + +pub fn cmsgclientucmgetpublishedfilesforuserresponse_unpack(buf []byte) ?CMsgClientUCmgetPublishedFilesForUserResponse { +mut res := CMsgClientUCmgetPublishedFilesForUserResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientucmgetpublishedfilesforuserresponsepublishedfileid(cur_buf, tag_wiretype.wire_type)? +res.published_files << v +i = ii +} + +3 { +res.has_total_results = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.total_results = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmgetpublishedfilesforuserresponse() CMsgClientUCmgetPublishedFilesForUserResponse { +return CMsgClientUCmgetPublishedFilesForUserResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmgetpublishedfilesforuserresponse(o CMsgClientUCmgetPublishedFilesForUserResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmgetpublishedfilesforuserresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmgetPublishedFilesForUserResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmgetpublishedfilesforuserresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmsetUserPublishedFileAction { +mut: +unknown_fields []vproto.UnknownField +pub mut: +published_file_id u64 +has_published_file_id bool +app_id u32 +has_app_id bool +action int +has_action bool +} +pub fn (o &CMsgClientUCmsetUserPublishedFileAction) pack() []byte { +mut res := []byte{} +if o.has_published_file_id { +res << vproto.pack_64bit_field(o.published_file_id, 1) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 2) +} + +if o.has_action { +res << vproto.pack_int32_field(o.action, 3) +} + +return res +} + +pub fn cmsgclientucmsetuserpublishedfileaction_unpack(buf []byte) ?CMsgClientUCmsetUserPublishedFileAction { +mut res := CMsgClientUCmsetUserPublishedFileAction{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_published_file_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.published_file_id = v +i = ii +} + +2 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +3 { +res.has_action = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.action = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmsetuserpublishedfileaction() CMsgClientUCmsetUserPublishedFileAction { +return CMsgClientUCmsetUserPublishedFileAction{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmsetuserpublishedfileaction(o CMsgClientUCmsetUserPublishedFileAction, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmsetuserpublishedfileaction(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmsetUserPublishedFileAction) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmsetuserpublishedfileaction_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmsetUserPublishedFileActionResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +} +pub fn (o &CMsgClientUCmsetUserPublishedFileActionResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +return res +} + +pub fn cmsgclientucmsetuserpublishedfileactionresponse_unpack(buf []byte) ?CMsgClientUCmsetUserPublishedFileActionResponse { +mut res := CMsgClientUCmsetUserPublishedFileActionResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmsetuserpublishedfileactionresponse() CMsgClientUCmsetUserPublishedFileActionResponse { +return CMsgClientUCmsetUserPublishedFileActionResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmsetuserpublishedfileactionresponse(o CMsgClientUCmsetUserPublishedFileActionResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmsetuserpublishedfileactionresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmsetUserPublishedFileActionResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmsetuserpublishedfileactionresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmenumeratePublishedFilesByUserAction { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +start_index u32 +has_start_index bool +action int +has_action bool +} +pub fn (o &CMsgClientUCmenumeratePublishedFilesByUserAction) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_start_index { +res << vproto.pack_uint32_field(o.start_index, 2) +} + +if o.has_action { +res << vproto.pack_int32_field(o.action, 3) +} + +return res +} + +pub fn cmsgclientucmenumeratepublishedfilesbyuseraction_unpack(buf []byte) ?CMsgClientUCmenumeratePublishedFilesByUserAction { +mut res := CMsgClientUCmenumeratePublishedFilesByUserAction{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_start_index = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.start_index = v +i = ii +} + +3 { +res.has_action = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.action = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmenumeratepublishedfilesbyuseraction() CMsgClientUCmenumeratePublishedFilesByUserAction { +return CMsgClientUCmenumeratePublishedFilesByUserAction{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmenumeratepublishedfilesbyuseraction(o CMsgClientUCmenumeratePublishedFilesByUserAction, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmenumeratepublishedfilesbyuseraction(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmenumeratePublishedFilesByUserAction) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmenumeratepublishedfilesbyuseraction_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmenumeratePublishedFilesByUserActionResponsePublishedFileId { +mut: +unknown_fields []vproto.UnknownField +pub mut: +published_file_id u64 +has_published_file_id bool +rtime_time_stamp u32 +has_rtime_time_stamp bool +} +pub fn (o &CMsgClientUCmenumeratePublishedFilesByUserActionResponsePublishedFileId) pack() []byte { +mut res := []byte{} +if o.has_published_file_id { +res << vproto.pack_64bit_field(o.published_file_id, 1) +} + +if o.has_rtime_time_stamp { +res << vproto.pack_32bit_field(o.rtime_time_stamp, 2) +} + +return res +} + +pub fn cmsgclientucmenumeratepublishedfilesbyuseractionresponsepublishedfileid_unpack(buf []byte) ?CMsgClientUCmenumeratePublishedFilesByUserActionResponsePublishedFileId { +mut res := CMsgClientUCmenumeratePublishedFilesByUserActionResponsePublishedFileId{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_published_file_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.published_file_id = v +i = ii +} + +2 { +res.has_rtime_time_stamp = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.rtime_time_stamp = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmenumeratepublishedfilesbyuseractionresponsepublishedfileid() CMsgClientUCmenumeratePublishedFilesByUserActionResponsePublishedFileId { +return CMsgClientUCmenumeratePublishedFilesByUserActionResponsePublishedFileId{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmenumeratepublishedfilesbyuseractionresponsepublishedfileid(o CMsgClientUCmenumeratePublishedFilesByUserActionResponsePublishedFileId, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmenumeratepublishedfilesbyuseractionresponsepublishedfileid(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmenumeratePublishedFilesByUserActionResponsePublishedFileId) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmenumeratepublishedfilesbyuseractionresponsepublishedfileid_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUCmenumeratePublishedFilesByUserActionResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +published_files []CMsgClientUCmenumeratePublishedFilesByUserActionResponsePublishedFileId +total_results u32 +has_total_results bool +} +pub fn (o &CMsgClientUCmenumeratePublishedFilesByUserActionResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +// [packed=false] +for _, x in o.published_files { +res << zzz_vproto_internal_pack_cmsgclientucmenumeratepublishedfilesbyuseractionresponsepublishedfileid(x, 2) +} + +if o.has_total_results { +res << vproto.pack_uint32_field(o.total_results, 3) +} + +return res +} + +pub fn cmsgclientucmenumeratepublishedfilesbyuseractionresponse_unpack(buf []byte) ?CMsgClientUCmenumeratePublishedFilesByUserActionResponse { +mut res := CMsgClientUCmenumeratePublishedFilesByUserActionResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientucmenumeratepublishedfilesbyuseractionresponsepublishedfileid(cur_buf, tag_wiretype.wire_type)? +res.published_files << v +i = ii +} + +3 { +res.has_total_results = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.total_results = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientucmenumeratepublishedfilesbyuseractionresponse() CMsgClientUCmenumeratePublishedFilesByUserActionResponse { +return CMsgClientUCmenumeratePublishedFilesByUserActionResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientucmenumeratepublishedfilesbyuseractionresponse(o CMsgClientUCmenumeratePublishedFilesByUserActionResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientucmenumeratepublishedfilesbyuseractionresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUCmenumeratePublishedFilesByUserActionResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientucmenumeratepublishedfilesbyuseractionresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientScreenshotsChanged { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CMsgClientScreenshotsChanged) pack() []byte { +res := []byte{} +return res +} + +pub fn cmsgclientscreenshotschanged_unpack(buf []byte) ?CMsgClientScreenshotsChanged { +res := CMsgClientScreenshotsChanged{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientscreenshotschanged() CMsgClientScreenshotsChanged { +return CMsgClientScreenshotsChanged{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientscreenshotschanged(o CMsgClientScreenshotsChanged, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientscreenshotschanged(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientScreenshotsChanged) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientscreenshotschanged_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUpdateUserGameInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid_idgs u64 +has_steamid_idgs bool +gameid u64 +has_gameid bool +game_ip u32 +has_game_ip bool +game_port u32 +has_game_port bool +token []byte +has_token bool +} +pub fn (o &CMsgClientUpdateUserGameInfo) pack() []byte { +mut res := []byte{} +if o.has_steamid_idgs { +res << vproto.pack_64bit_field(o.steamid_idgs, 1) +} + +if o.has_gameid { +res << vproto.pack_64bit_field(o.gameid, 2) +} + +if o.has_game_ip { +res << vproto.pack_uint32_field(o.game_ip, 3) +} + +if o.has_game_port { +res << vproto.pack_uint32_field(o.game_port, 4) +} + +if o.has_token { +res << vproto.pack_bytes_field(o.token, 5) +} + +return res +} + +pub fn cmsgclientupdateusergameinfo_unpack(buf []byte) ?CMsgClientUpdateUserGameInfo { +mut res := CMsgClientUpdateUserGameInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid_idgs = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_idgs = v +i = ii +} + +2 { +res.has_gameid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.gameid = v +i = ii +} + +3 { +res.has_game_ip = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.game_ip = v +i = ii +} + +4 { +res.has_game_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.game_port = v +i = ii +} + +5 { +res.has_token = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientupdateusergameinfo() CMsgClientUpdateUserGameInfo { +return CMsgClientUpdateUserGameInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientupdateusergameinfo(o CMsgClientUpdateUserGameInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientupdateusergameinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUpdateUserGameInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientupdateusergameinfo_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRichPresenceUpload { +mut: +unknown_fields []vproto.UnknownField +pub mut: +rich_presence_kv []byte +has_rich_presence_kv bool +steamid_broadcast []u64 +} +pub fn (o &CMsgClientRichPresenceUpload) pack() []byte { +mut res := []byte{} +if o.has_rich_presence_kv { +res << vproto.pack_bytes_field(o.rich_presence_kv, 1) +} + +// [packed=false] +for _, x in o.steamid_broadcast { +res << vproto.pack_64bit_field(x, 2) +} + +return res +} + +pub fn cmsgclientrichpresenceupload_unpack(buf []byte) ?CMsgClientRichPresenceUpload { +mut res := CMsgClientRichPresenceUpload{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_rich_presence_kv = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.rich_presence_kv = v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_broadcast << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientrichpresenceupload() CMsgClientRichPresenceUpload { +return CMsgClientRichPresenceUpload{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientrichpresenceupload(o CMsgClientRichPresenceUpload, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientrichpresenceupload(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRichPresenceUpload) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientrichpresenceupload_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRichPresenceRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid_request []u64 +} +pub fn (o &CMsgClientRichPresenceRequest) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.steamid_request { +res << vproto.pack_64bit_field(x, 1) +} + +return res +} + +pub fn cmsgclientrichpresencerequest_unpack(buf []byte) ?CMsgClientRichPresenceRequest { +mut res := CMsgClientRichPresenceRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_request << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientrichpresencerequest() CMsgClientRichPresenceRequest { +return CMsgClientRichPresenceRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientrichpresencerequest(o CMsgClientRichPresenceRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientrichpresencerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRichPresenceRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientrichpresencerequest_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRichPresenceInfoRichPresence { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid_user u64 +has_steamid_user bool +rich_presence_kv []byte +has_rich_presence_kv bool +} +pub fn (o &CMsgClientRichPresenceInfoRichPresence) pack() []byte { +mut res := []byte{} +if o.has_steamid_user { +res << vproto.pack_64bit_field(o.steamid_user, 1) +} + +if o.has_rich_presence_kv { +res << vproto.pack_bytes_field(o.rich_presence_kv, 2) +} + +return res +} + +pub fn cmsgclientrichpresenceinforichpresence_unpack(buf []byte) ?CMsgClientRichPresenceInfoRichPresence { +mut res := CMsgClientRichPresenceInfoRichPresence{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid_user = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_user = v +i = ii +} + +2 { +res.has_rich_presence_kv = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.rich_presence_kv = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientrichpresenceinforichpresence() CMsgClientRichPresenceInfoRichPresence { +return CMsgClientRichPresenceInfoRichPresence{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientrichpresenceinforichpresence(o CMsgClientRichPresenceInfoRichPresence, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientrichpresenceinforichpresence(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRichPresenceInfoRichPresence) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientrichpresenceinforichpresence_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRichPresenceInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +rich_presence []CMsgClientRichPresenceInfoRichPresence +} +pub fn (o &CMsgClientRichPresenceInfo) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.rich_presence { +res << zzz_vproto_internal_pack_cmsgclientrichpresenceinforichpresence(x, 1) +} + +return res +} + +pub fn cmsgclientrichpresenceinfo_unpack(buf []byte) ?CMsgClientRichPresenceInfo { +mut res := CMsgClientRichPresenceInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientrichpresenceinforichpresence(cur_buf, tag_wiretype.wire_type)? +res.rich_presence << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientrichpresenceinfo() CMsgClientRichPresenceInfo { +return CMsgClientRichPresenceInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientrichpresenceinfo(o CMsgClientRichPresenceInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientrichpresenceinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRichPresenceInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientrichpresenceinfo_unpack(v)? +return i, unpacked +} +pub struct CMsgClientCheckFileSignature { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +} +pub fn (o &CMsgClientCheckFileSignature) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +return res +} + +pub fn cmsgclientcheckfilesignature_unpack(buf []byte) ?CMsgClientCheckFileSignature { +mut res := CMsgClientCheckFileSignature{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientcheckfilesignature() CMsgClientCheckFileSignature { +return CMsgClientCheckFileSignature{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientcheckfilesignature(o CMsgClientCheckFileSignature, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientcheckfilesignature(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientCheckFileSignature) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientcheckfilesignature_unpack(v)? +return i, unpacked +} +pub struct CMsgClientCheckFileSignatureResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +pid u32 +has_pid bool +eresult u32 +has_eresult bool +filename string +has_filename bool +esignatureresult u32 +has_esignatureresult bool +sha_file []byte +has_sha_file bool +signatureheader []byte +has_signatureheader bool +filesize u32 +has_filesize bool +getlasterror u32 +has_getlasterror bool +evalvesignaturecheckdetail u32 +has_evalvesignaturecheckdetail bool +} +pub fn (o &CMsgClientCheckFileSignatureResponse) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_pid { +res << vproto.pack_uint32_field(o.pid, 2) +} + +if o.has_eresult { +res << vproto.pack_uint32_field(o.eresult, 3) +} + +if o.has_filename { +res << vproto.pack_string_field(o.filename, 4) +} + +if o.has_esignatureresult { +res << vproto.pack_uint32_field(o.esignatureresult, 5) +} + +if o.has_sha_file { +res << vproto.pack_bytes_field(o.sha_file, 6) +} + +if o.has_signatureheader { +res << vproto.pack_bytes_field(o.signatureheader, 7) +} + +if o.has_filesize { +res << vproto.pack_uint32_field(o.filesize, 8) +} + +if o.has_getlasterror { +res << vproto.pack_uint32_field(o.getlasterror, 9) +} + +if o.has_evalvesignaturecheckdetail { +res << vproto.pack_uint32_field(o.evalvesignaturecheckdetail, 10) +} + +return res +} + +pub fn cmsgclientcheckfilesignatureresponse_unpack(buf []byte) ?CMsgClientCheckFileSignatureResponse { +mut res := CMsgClientCheckFileSignatureResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_pid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.pid = v +i = ii +} + +3 { +res.has_eresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +4 { +res.has_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.filename = v +i = ii +} + +5 { +res.has_esignatureresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.esignatureresult = v +i = ii +} + +6 { +res.has_sha_file = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha_file = v +i = ii +} + +7 { +res.has_signatureheader = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.signatureheader = v +i = ii +} + +8 { +res.has_filesize = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.filesize = v +i = ii +} + +9 { +res.has_getlasterror = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.getlasterror = v +i = ii +} + +10 { +res.has_evalvesignaturecheckdetail = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.evalvesignaturecheckdetail = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientcheckfilesignatureresponse() CMsgClientCheckFileSignatureResponse { +return CMsgClientCheckFileSignatureResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientcheckfilesignatureresponse(o CMsgClientCheckFileSignatureResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientcheckfilesignatureresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientCheckFileSignatureResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientcheckfilesignatureresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientReadMachineAuth { +mut: +unknown_fields []vproto.UnknownField +pub mut: +filename string +has_filename bool +offset u32 +has_offset bool +cubtoread u32 +has_cubtoread bool +} +pub fn (o &CMsgClientReadMachineAuth) pack() []byte { +mut res := []byte{} +if o.has_filename { +res << vproto.pack_string_field(o.filename, 1) +} + +if o.has_offset { +res << vproto.pack_uint32_field(o.offset, 2) +} + +if o.has_cubtoread { +res << vproto.pack_uint32_field(o.cubtoread, 3) +} + +return res +} + +pub fn cmsgclientreadmachineauth_unpack(buf []byte) ?CMsgClientReadMachineAuth { +mut res := CMsgClientReadMachineAuth{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.filename = v +i = ii +} + +2 { +res.has_offset = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.offset = v +i = ii +} + +3 { +res.has_cubtoread = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cubtoread = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientreadmachineauth() CMsgClientReadMachineAuth { +return CMsgClientReadMachineAuth{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientreadmachineauth(o CMsgClientReadMachineAuth, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientreadmachineauth(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientReadMachineAuth) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientreadmachineauth_unpack(v)? +return i, unpacked +} +pub struct CMsgClientReadMachineAuthResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +filename string +has_filename bool +eresult u32 +has_eresult bool +filesize u32 +has_filesize bool +sha_file []byte +has_sha_file bool +getlasterror u32 +has_getlasterror bool +offset u32 +has_offset bool +cubread u32 +has_cubread bool +bytes_read []byte +has_bytes_read bool +filename_sentry string +has_filename_sentry bool +} +pub fn (o &CMsgClientReadMachineAuthResponse) pack() []byte { +mut res := []byte{} +if o.has_filename { +res << vproto.pack_string_field(o.filename, 1) +} + +if o.has_eresult { +res << vproto.pack_uint32_field(o.eresult, 2) +} + +if o.has_filesize { +res << vproto.pack_uint32_field(o.filesize, 3) +} + +if o.has_sha_file { +res << vproto.pack_bytes_field(o.sha_file, 4) +} + +if o.has_getlasterror { +res << vproto.pack_uint32_field(o.getlasterror, 5) +} + +if o.has_offset { +res << vproto.pack_uint32_field(o.offset, 6) +} + +if o.has_cubread { +res << vproto.pack_uint32_field(o.cubread, 7) +} + +if o.has_bytes_read { +res << vproto.pack_bytes_field(o.bytes_read, 8) +} + +if o.has_filename_sentry { +res << vproto.pack_string_field(o.filename_sentry, 9) +} + +return res +} + +pub fn cmsgclientreadmachineauthresponse_unpack(buf []byte) ?CMsgClientReadMachineAuthResponse { +mut res := CMsgClientReadMachineAuthResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.filename = v +i = ii +} + +2 { +res.has_eresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +3 { +res.has_filesize = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.filesize = v +i = ii +} + +4 { +res.has_sha_file = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha_file = v +i = ii +} + +5 { +res.has_getlasterror = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.getlasterror = v +i = ii +} + +6 { +res.has_offset = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.offset = v +i = ii +} + +7 { +res.has_cubread = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cubread = v +i = ii +} + +8 { +res.has_bytes_read = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.bytes_read = v +i = ii +} + +9 { +res.has_filename_sentry = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.filename_sentry = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientreadmachineauthresponse() CMsgClientReadMachineAuthResponse { +return CMsgClientReadMachineAuthResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientreadmachineauthresponse(o CMsgClientReadMachineAuthResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientreadmachineauthresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientReadMachineAuthResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientreadmachineauthresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUpdateMachineAuth { +mut: +unknown_fields []vproto.UnknownField +pub mut: +filename string +has_filename bool +offset u32 +has_offset bool +cubtowrite u32 +has_cubtowrite bool +bytes []byte +has_bytes bool +otp_type u32 +has_otp_type bool +otp_identifier string +has_otp_identifier bool +otp_sharedsecret []byte +has_otp_sharedsecret bool +otp_timedrift u32 +has_otp_timedrift bool +} +pub fn (o &CMsgClientUpdateMachineAuth) pack() []byte { +mut res := []byte{} +if o.has_filename { +res << vproto.pack_string_field(o.filename, 1) +} + +if o.has_offset { +res << vproto.pack_uint32_field(o.offset, 2) +} + +if o.has_cubtowrite { +res << vproto.pack_uint32_field(o.cubtowrite, 3) +} + +if o.has_bytes { +res << vproto.pack_bytes_field(o.bytes, 4) +} + +if o.has_otp_type { +res << vproto.pack_uint32_field(o.otp_type, 5) +} + +if o.has_otp_identifier { +res << vproto.pack_string_field(o.otp_identifier, 6) +} + +if o.has_otp_sharedsecret { +res << vproto.pack_bytes_field(o.otp_sharedsecret, 7) +} + +if o.has_otp_timedrift { +res << vproto.pack_uint32_field(o.otp_timedrift, 8) +} + +return res +} + +pub fn cmsgclientupdatemachineauth_unpack(buf []byte) ?CMsgClientUpdateMachineAuth { +mut res := CMsgClientUpdateMachineAuth{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.filename = v +i = ii +} + +2 { +res.has_offset = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.offset = v +i = ii +} + +3 { +res.has_cubtowrite = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cubtowrite = v +i = ii +} + +4 { +res.has_bytes = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.bytes = v +i = ii +} + +5 { +res.has_otp_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.otp_type = v +i = ii +} + +6 { +res.has_otp_identifier = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.otp_identifier = v +i = ii +} + +7 { +res.has_otp_sharedsecret = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.otp_sharedsecret = v +i = ii +} + +8 { +res.has_otp_timedrift = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.otp_timedrift = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientupdatemachineauth() CMsgClientUpdateMachineAuth { +return CMsgClientUpdateMachineAuth{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientupdatemachineauth(o CMsgClientUpdateMachineAuth, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientupdatemachineauth(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUpdateMachineAuth) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientupdatemachineauth_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUpdateMachineAuthResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +filename string +has_filename bool +eresult u32 +has_eresult bool +filesize u32 +has_filesize bool +sha_file []byte +has_sha_file bool +getlasterror u32 +has_getlasterror bool +offset u32 +has_offset bool +cubwrote u32 +has_cubwrote bool +otp_type int +has_otp_type bool +otp_value u32 +has_otp_value bool +otp_identifier string +has_otp_identifier bool +} +pub fn (o &CMsgClientUpdateMachineAuthResponse) pack() []byte { +mut res := []byte{} +if o.has_filename { +res << vproto.pack_string_field(o.filename, 1) +} + +if o.has_eresult { +res << vproto.pack_uint32_field(o.eresult, 2) +} + +if o.has_filesize { +res << vproto.pack_uint32_field(o.filesize, 3) +} + +if o.has_sha_file { +res << vproto.pack_bytes_field(o.sha_file, 4) +} + +if o.has_getlasterror { +res << vproto.pack_uint32_field(o.getlasterror, 5) +} + +if o.has_offset { +res << vproto.pack_uint32_field(o.offset, 6) +} + +if o.has_cubwrote { +res << vproto.pack_uint32_field(o.cubwrote, 7) +} + +if o.has_otp_type { +res << vproto.pack_int32_field(o.otp_type, 8) +} + +if o.has_otp_value { +res << vproto.pack_uint32_field(o.otp_value, 9) +} + +if o.has_otp_identifier { +res << vproto.pack_string_field(o.otp_identifier, 10) +} + +return res +} + +pub fn cmsgclientupdatemachineauthresponse_unpack(buf []byte) ?CMsgClientUpdateMachineAuthResponse { +mut res := CMsgClientUpdateMachineAuthResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.filename = v +i = ii +} + +2 { +res.has_eresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +3 { +res.has_filesize = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.filesize = v +i = ii +} + +4 { +res.has_sha_file = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha_file = v +i = ii +} + +5 { +res.has_getlasterror = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.getlasterror = v +i = ii +} + +6 { +res.has_offset = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.offset = v +i = ii +} + +7 { +res.has_cubwrote = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cubwrote = v +i = ii +} + +8 { +res.has_otp_type = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.otp_type = v +i = ii +} + +9 { +res.has_otp_value = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.otp_value = v +i = ii +} + +10 { +res.has_otp_identifier = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.otp_identifier = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientupdatemachineauthresponse() CMsgClientUpdateMachineAuthResponse { +return CMsgClientUpdateMachineAuthResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientupdatemachineauthresponse(o CMsgClientUpdateMachineAuthResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientupdatemachineauthresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUpdateMachineAuthResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientupdatemachineauthresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRequestMachineAuth { +mut: +unknown_fields []vproto.UnknownField +pub mut: +filename string +has_filename bool +eresult_sentryfile u32 +has_eresult_sentryfile bool +filesize u32 +has_filesize bool +sha_sentryfile []byte +has_sha_sentryfile bool +lock_account_action int +has_lock_account_action bool +otp_type u32 +has_otp_type bool +otp_identifier string +has_otp_identifier bool +otp_sharedsecret []byte +has_otp_sharedsecret bool +otp_value u32 +has_otp_value bool +machine_name string +has_machine_name bool +machine_name_userchosen string +has_machine_name_userchosen bool +} +pub fn (o &CMsgClientRequestMachineAuth) pack() []byte { +mut res := []byte{} +if o.has_filename { +res << vproto.pack_string_field(o.filename, 1) +} + +if o.has_eresult_sentryfile { +res << vproto.pack_uint32_field(o.eresult_sentryfile, 2) +} + +if o.has_filesize { +res << vproto.pack_uint32_field(o.filesize, 3) +} + +if o.has_sha_sentryfile { +res << vproto.pack_bytes_field(o.sha_sentryfile, 4) +} + +if o.has_lock_account_action { +res << vproto.pack_int32_field(o.lock_account_action, 6) +} + +if o.has_otp_type { +res << vproto.pack_uint32_field(o.otp_type, 7) +} + +if o.has_otp_identifier { +res << vproto.pack_string_field(o.otp_identifier, 8) +} + +if o.has_otp_sharedsecret { +res << vproto.pack_bytes_field(o.otp_sharedsecret, 9) +} + +if o.has_otp_value { +res << vproto.pack_uint32_field(o.otp_value, 10) +} + +if o.has_machine_name { +res << vproto.pack_string_field(o.machine_name, 11) +} + +if o.has_machine_name_userchosen { +res << vproto.pack_string_field(o.machine_name_userchosen, 12) +} + +return res +} + +pub fn cmsgclientrequestmachineauth_unpack(buf []byte) ?CMsgClientRequestMachineAuth { +mut res := CMsgClientRequestMachineAuth{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.filename = v +i = ii +} + +2 { +res.has_eresult_sentryfile = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult_sentryfile = v +i = ii +} + +3 { +res.has_filesize = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.filesize = v +i = ii +} + +4 { +res.has_sha_sentryfile = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha_sentryfile = v +i = ii +} + +6 { +res.has_lock_account_action = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.lock_account_action = v +i = ii +} + +7 { +res.has_otp_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.otp_type = v +i = ii +} + +8 { +res.has_otp_identifier = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.otp_identifier = v +i = ii +} + +9 { +res.has_otp_sharedsecret = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.otp_sharedsecret = v +i = ii +} + +10 { +res.has_otp_value = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.otp_value = v +i = ii +} + +11 { +res.has_machine_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.machine_name = v +i = ii +} + +12 { +res.has_machine_name_userchosen = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.machine_name_userchosen = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientrequestmachineauth() CMsgClientRequestMachineAuth { +return CMsgClientRequestMachineAuth{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientrequestmachineauth(o CMsgClientRequestMachineAuth, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientrequestmachineauth(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRequestMachineAuth) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientrequestmachineauth_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRequestMachineAuthResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult u32 +has_eresult bool +} +pub fn (o &CMsgClientRequestMachineAuthResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_uint32_field(o.eresult, 1) +} + +return res +} + +pub fn cmsgclientrequestmachineauthresponse_unpack(buf []byte) ?CMsgClientRequestMachineAuthResponse { +mut res := CMsgClientRequestMachineAuthResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientrequestmachineauthresponse() CMsgClientRequestMachineAuthResponse { +return CMsgClientRequestMachineAuthResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientrequestmachineauthresponse(o CMsgClientRequestMachineAuthResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientrequestmachineauthresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRequestMachineAuthResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientrequestmachineauthresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRegisterKey { +mut: +unknown_fields []vproto.UnknownField +pub mut: +key string +has_key bool +} +pub fn (o &CMsgClientRegisterKey) pack() []byte { +mut res := []byte{} +if o.has_key { +res << vproto.pack_string_field(o.key, 1) +} + +return res +} + +pub fn cmsgclientregisterkey_unpack(buf []byte) ?CMsgClientRegisterKey { +mut res := CMsgClientRegisterKey{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_key = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.key = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientregisterkey() CMsgClientRegisterKey { +return CMsgClientRegisterKey{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientregisterkey(o CMsgClientRegisterKey, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientregisterkey(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRegisterKey) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientregisterkey_unpack(v)? +return i, unpacked +} +pub struct CMsgClientPurchaseResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +purchase_result_details int +has_purchase_result_details bool +purchase_receipt_info []byte +has_purchase_receipt_info bool +} +pub fn (o &CMsgClientPurchaseResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_purchase_result_details { +res << vproto.pack_int32_field(o.purchase_result_details, 2) +} + +if o.has_purchase_receipt_info { +res << vproto.pack_bytes_field(o.purchase_receipt_info, 3) +} + +return res +} + +pub fn cmsgclientpurchaseresponse_unpack(buf []byte) ?CMsgClientPurchaseResponse { +mut res := CMsgClientPurchaseResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_purchase_result_details = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.purchase_result_details = v +i = ii +} + +3 { +res.has_purchase_receipt_info = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.purchase_receipt_info = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientpurchaseresponse() CMsgClientPurchaseResponse { +return CMsgClientPurchaseResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientpurchaseresponse(o CMsgClientPurchaseResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientpurchaseresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientPurchaseResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientpurchaseresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientActivateOEmlicense { +mut: +unknown_fields []vproto.UnknownField +pub mut: +bios_manufacturer string +has_bios_manufacturer bool +bios_serialnumber string +has_bios_serialnumber bool +license_file []byte +has_license_file bool +mainboard_manufacturer string +has_mainboard_manufacturer bool +mainboard_product string +has_mainboard_product bool +mainboard_serialnumber string +has_mainboard_serialnumber bool +} +pub fn (o &CMsgClientActivateOEmlicense) pack() []byte { +mut res := []byte{} +if o.has_bios_manufacturer { +res << vproto.pack_string_field(o.bios_manufacturer, 1) +} + +if o.has_bios_serialnumber { +res << vproto.pack_string_field(o.bios_serialnumber, 2) +} + +if o.has_license_file { +res << vproto.pack_bytes_field(o.license_file, 3) +} + +if o.has_mainboard_manufacturer { +res << vproto.pack_string_field(o.mainboard_manufacturer, 4) +} + +if o.has_mainboard_product { +res << vproto.pack_string_field(o.mainboard_product, 5) +} + +if o.has_mainboard_serialnumber { +res << vproto.pack_string_field(o.mainboard_serialnumber, 6) +} + +return res +} + +pub fn cmsgclientactivateoemlicense_unpack(buf []byte) ?CMsgClientActivateOEmlicense { +mut res := CMsgClientActivateOEmlicense{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_bios_manufacturer = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.bios_manufacturer = v +i = ii +} + +2 { +res.has_bios_serialnumber = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.bios_serialnumber = v +i = ii +} + +3 { +res.has_license_file = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.license_file = v +i = ii +} + +4 { +res.has_mainboard_manufacturer = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.mainboard_manufacturer = v +i = ii +} + +5 { +res.has_mainboard_product = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.mainboard_product = v +i = ii +} + +6 { +res.has_mainboard_serialnumber = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.mainboard_serialnumber = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientactivateoemlicense() CMsgClientActivateOEmlicense { +return CMsgClientActivateOEmlicense{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientactivateoemlicense(o CMsgClientActivateOEmlicense, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientactivateoemlicense(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientActivateOEmlicense) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientactivateoemlicense_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRegisterOEmmachine { +mut: +unknown_fields []vproto.UnknownField +pub mut: +oem_register_file []byte +has_oem_register_file bool +} +pub fn (o &CMsgClientRegisterOEmmachine) pack() []byte { +mut res := []byte{} +if o.has_oem_register_file { +res << vproto.pack_bytes_field(o.oem_register_file, 1) +} + +return res +} + +pub fn cmsgclientregisteroemmachine_unpack(buf []byte) ?CMsgClientRegisterOEmmachine { +mut res := CMsgClientRegisterOEmmachine{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_oem_register_file = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.oem_register_file = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientregisteroemmachine() CMsgClientRegisterOEmmachine { +return CMsgClientRegisterOEmmachine{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientregisteroemmachine(o CMsgClientRegisterOEmmachine, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientregisteroemmachine(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRegisterOEmmachine) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientregisteroemmachine_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRegisterOEmmachineResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult u32 +has_eresult bool +} +pub fn (o &CMsgClientRegisterOEmmachineResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_uint32_field(o.eresult, 1) +} + +return res +} + +pub fn cmsgclientregisteroemmachineresponse_unpack(buf []byte) ?CMsgClientRegisterOEmmachineResponse { +mut res := CMsgClientRegisterOEmmachineResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientregisteroemmachineresponse() CMsgClientRegisterOEmmachineResponse { +return CMsgClientRegisterOEmmachineResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientregisteroemmachineresponse(o CMsgClientRegisterOEmmachineResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientregisteroemmachineresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRegisterOEmmachineResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientregisteroemmachineresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientPurchaseWithMachineID { +mut: +unknown_fields []vproto.UnknownField +pub mut: +package_id u32 +has_package_id bool +machine_info []byte +has_machine_info bool +} +pub fn (o &CMsgClientPurchaseWithMachineID) pack() []byte { +mut res := []byte{} +if o.has_package_id { +res << vproto.pack_uint32_field(o.package_id, 1) +} + +if o.has_machine_info { +res << vproto.pack_bytes_field(o.machine_info, 2) +} + +return res +} + +pub fn cmsgclientpurchasewithmachineid_unpack(buf []byte) ?CMsgClientPurchaseWithMachineID { +mut res := CMsgClientPurchaseWithMachineID{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_package_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.package_id = v +i = ii +} + +2 { +res.has_machine_info = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.machine_info = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientpurchasewithmachineid() CMsgClientPurchaseWithMachineID { +return CMsgClientPurchaseWithMachineID{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientpurchasewithmachineid(o CMsgClientPurchaseWithMachineID, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientpurchasewithmachineid(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientPurchaseWithMachineID) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientpurchasewithmachineid_unpack(v)? +return i, unpacked +} +pub struct CMsgTradingInitiateTradeRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +trade_request_id u32 +has_trade_request_id bool +other_steamid u64 +has_other_steamid bool +other_name string +has_other_name bool +} +pub fn (o &CMsgTradingInitiateTradeRequest) pack() []byte { +mut res := []byte{} +if o.has_trade_request_id { +res << vproto.pack_uint32_field(o.trade_request_id, 1) +} + +if o.has_other_steamid { +res << vproto.pack_uint64_field(o.other_steamid, 2) +} + +if o.has_other_name { +res << vproto.pack_string_field(o.other_name, 3) +} + +return res +} + +pub fn cmsgtradinginitiatetraderequest_unpack(buf []byte) ?CMsgTradingInitiateTradeRequest { +mut res := CMsgTradingInitiateTradeRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_trade_request_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.trade_request_id = v +i = ii +} + +2 { +res.has_other_steamid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.other_steamid = v +i = ii +} + +3 { +res.has_other_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.other_name = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgtradinginitiatetraderequest() CMsgTradingInitiateTradeRequest { +return CMsgTradingInitiateTradeRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgtradinginitiatetraderequest(o CMsgTradingInitiateTradeRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgtradinginitiatetraderequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgTradingInitiateTradeRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgtradinginitiatetraderequest_unpack(v)? +return i, unpacked +} +pub struct CMsgTradingInitiateTradeResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +response u32 +has_response bool +trade_request_id u32 +has_trade_request_id bool +other_steamid u64 +has_other_steamid bool +steamguard_required_days u32 +has_steamguard_required_days bool +new_device_cooldown_days u32 +has_new_device_cooldown_days bool +default_password_reset_probation_days u32 +has_default_password_reset_probation_days bool +password_reset_probation_days u32 +has_password_reset_probation_days bool +default_email_change_probation_days u32 +has_default_email_change_probation_days bool +email_change_probation_days u32 +has_email_change_probation_days bool +} +pub fn (o &CMsgTradingInitiateTradeResponse) pack() []byte { +mut res := []byte{} +if o.has_response { +res << vproto.pack_uint32_field(o.response, 1) +} + +if o.has_trade_request_id { +res << vproto.pack_uint32_field(o.trade_request_id, 2) +} + +if o.has_other_steamid { +res << vproto.pack_uint64_field(o.other_steamid, 3) +} + +if o.has_steamguard_required_days { +res << vproto.pack_uint32_field(o.steamguard_required_days, 4) +} + +if o.has_new_device_cooldown_days { +res << vproto.pack_uint32_field(o.new_device_cooldown_days, 5) +} + +if o.has_default_password_reset_probation_days { +res << vproto.pack_uint32_field(o.default_password_reset_probation_days, 6) +} + +if o.has_password_reset_probation_days { +res << vproto.pack_uint32_field(o.password_reset_probation_days, 7) +} + +if o.has_default_email_change_probation_days { +res << vproto.pack_uint32_field(o.default_email_change_probation_days, 8) +} + +if o.has_email_change_probation_days { +res << vproto.pack_uint32_field(o.email_change_probation_days, 9) +} + +return res +} + +pub fn cmsgtradinginitiatetraderesponse_unpack(buf []byte) ?CMsgTradingInitiateTradeResponse { +mut res := CMsgTradingInitiateTradeResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_response = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.response = v +i = ii +} + +2 { +res.has_trade_request_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.trade_request_id = v +i = ii +} + +3 { +res.has_other_steamid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.other_steamid = v +i = ii +} + +4 { +res.has_steamguard_required_days = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.steamguard_required_days = v +i = ii +} + +5 { +res.has_new_device_cooldown_days = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.new_device_cooldown_days = v +i = ii +} + +6 { +res.has_default_password_reset_probation_days = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.default_password_reset_probation_days = v +i = ii +} + +7 { +res.has_password_reset_probation_days = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.password_reset_probation_days = v +i = ii +} + +8 { +res.has_default_email_change_probation_days = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.default_email_change_probation_days = v +i = ii +} + +9 { +res.has_email_change_probation_days = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.email_change_probation_days = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgtradinginitiatetraderesponse() CMsgTradingInitiateTradeResponse { +return CMsgTradingInitiateTradeResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgtradinginitiatetraderesponse(o CMsgTradingInitiateTradeResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgtradinginitiatetraderesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgTradingInitiateTradeResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgtradinginitiatetraderesponse_unpack(v)? +return i, unpacked +} +pub struct CMsgTradingCancelTradeRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +other_steamid u64 +has_other_steamid bool +} +pub fn (o &CMsgTradingCancelTradeRequest) pack() []byte { +mut res := []byte{} +if o.has_other_steamid { +res << vproto.pack_uint64_field(o.other_steamid, 1) +} + +return res +} + +pub fn cmsgtradingcanceltraderequest_unpack(buf []byte) ?CMsgTradingCancelTradeRequest { +mut res := CMsgTradingCancelTradeRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_other_steamid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.other_steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgtradingcanceltraderequest() CMsgTradingCancelTradeRequest { +return CMsgTradingCancelTradeRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgtradingcanceltraderequest(o CMsgTradingCancelTradeRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgtradingcanceltraderequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgTradingCancelTradeRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgtradingcanceltraderequest_unpack(v)? +return i, unpacked +} +pub struct CMsgTradingStartSession { +mut: +unknown_fields []vproto.UnknownField +pub mut: +other_steamid u64 +has_other_steamid bool +} +pub fn (o &CMsgTradingStartSession) pack() []byte { +mut res := []byte{} +if o.has_other_steamid { +res << vproto.pack_uint64_field(o.other_steamid, 1) +} + +return res +} + +pub fn cmsgtradingstartsession_unpack(buf []byte) ?CMsgTradingStartSession { +mut res := CMsgTradingStartSession{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_other_steamid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.other_steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgtradingstartsession() CMsgTradingStartSession { +return CMsgTradingStartSession{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgtradingstartsession(o CMsgTradingStartSession, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgtradingstartsession(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgTradingStartSession) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgtradingstartsession_unpack(v)? +return i, unpacked +} +pub struct CMsgClientGetCDnauthToken { +mut: +unknown_fields []vproto.UnknownField +pub mut: +depot_id u32 +has_depot_id bool +host_name string +has_host_name bool +app_id u32 +has_app_id bool +} +pub fn (o &CMsgClientGetCDnauthToken) pack() []byte { +mut res := []byte{} +if o.has_depot_id { +res << vproto.pack_uint32_field(o.depot_id, 1) +} + +if o.has_host_name { +res << vproto.pack_string_field(o.host_name, 2) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 3) +} + +return res +} + +pub fn cmsgclientgetcdnauthtoken_unpack(buf []byte) ?CMsgClientGetCDnauthToken { +mut res := CMsgClientGetCDnauthToken{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_depot_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.depot_id = v +i = ii +} + +2 { +res.has_host_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.host_name = v +i = ii +} + +3 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientgetcdnauthtoken() CMsgClientGetCDnauthToken { +return CMsgClientGetCDnauthToken{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientgetcdnauthtoken(o CMsgClientGetCDnauthToken, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientgetcdnauthtoken(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientGetCDnauthToken) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientgetcdnauthtoken_unpack(v)? +return i, unpacked +} +pub struct CMsgClientGetDepotDecryptionKey { +mut: +unknown_fields []vproto.UnknownField +pub mut: +depot_id u32 +has_depot_id bool +app_id u32 +has_app_id bool +} +pub fn (o &CMsgClientGetDepotDecryptionKey) pack() []byte { +mut res := []byte{} +if o.has_depot_id { +res << vproto.pack_uint32_field(o.depot_id, 1) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 2) +} + +return res +} + +pub fn cmsgclientgetdepotdecryptionkey_unpack(buf []byte) ?CMsgClientGetDepotDecryptionKey { +mut res := CMsgClientGetDepotDecryptionKey{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_depot_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.depot_id = v +i = ii +} + +2 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientgetdepotdecryptionkey() CMsgClientGetDepotDecryptionKey { +return CMsgClientGetDepotDecryptionKey{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientgetdepotdecryptionkey(o CMsgClientGetDepotDecryptionKey, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientgetdepotdecryptionkey(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientGetDepotDecryptionKey) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientgetdepotdecryptionkey_unpack(v)? +return i, unpacked +} +pub struct CMsgClientGetDepotDecryptionKeyResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +depot_id u32 +has_depot_id bool +depot_encryption_key []byte +has_depot_encryption_key bool +} +pub fn (o &CMsgClientGetDepotDecryptionKeyResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_depot_id { +res << vproto.pack_uint32_field(o.depot_id, 2) +} + +if o.has_depot_encryption_key { +res << vproto.pack_bytes_field(o.depot_encryption_key, 3) +} + +return res +} + +pub fn cmsgclientgetdepotdecryptionkeyresponse_unpack(buf []byte) ?CMsgClientGetDepotDecryptionKeyResponse { +mut res := CMsgClientGetDepotDecryptionKeyResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_depot_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.depot_id = v +i = ii +} + +3 { +res.has_depot_encryption_key = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.depot_encryption_key = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientgetdepotdecryptionkeyresponse() CMsgClientGetDepotDecryptionKeyResponse { +return CMsgClientGetDepotDecryptionKeyResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientgetdepotdecryptionkeyresponse(o CMsgClientGetDepotDecryptionKeyResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientgetdepotdecryptionkeyresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientGetDepotDecryptionKeyResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientgetdepotdecryptionkeyresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientCheckAppBetaPassword { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +betapassword string +has_betapassword bool +} +pub fn (o &CMsgClientCheckAppBetaPassword) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_betapassword { +res << vproto.pack_string_field(o.betapassword, 2) +} + +return res +} + +pub fn cmsgclientcheckappbetapassword_unpack(buf []byte) ?CMsgClientCheckAppBetaPassword { +mut res := CMsgClientCheckAppBetaPassword{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_betapassword = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.betapassword = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientcheckappbetapassword() CMsgClientCheckAppBetaPassword { +return CMsgClientCheckAppBetaPassword{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientcheckappbetapassword(o CMsgClientCheckAppBetaPassword, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientcheckappbetapassword(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientCheckAppBetaPassword) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientcheckappbetapassword_unpack(v)? +return i, unpacked +} +pub struct CMsgClientCheckAppBetaPasswordResponseBetaPassword { +mut: +unknown_fields []vproto.UnknownField +pub mut: +betaname string +has_betaname bool +betapassword string +has_betapassword bool +} +pub fn (o &CMsgClientCheckAppBetaPasswordResponseBetaPassword) pack() []byte { +mut res := []byte{} +if o.has_betaname { +res << vproto.pack_string_field(o.betaname, 1) +} + +if o.has_betapassword { +res << vproto.pack_string_field(o.betapassword, 2) +} + +return res +} + +pub fn cmsgclientcheckappbetapasswordresponsebetapassword_unpack(buf []byte) ?CMsgClientCheckAppBetaPasswordResponseBetaPassword { +mut res := CMsgClientCheckAppBetaPasswordResponseBetaPassword{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_betaname = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.betaname = v +i = ii +} + +2 { +res.has_betapassword = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.betapassword = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientcheckappbetapasswordresponsebetapassword() CMsgClientCheckAppBetaPasswordResponseBetaPassword { +return CMsgClientCheckAppBetaPasswordResponseBetaPassword{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientcheckappbetapasswordresponsebetapassword(o CMsgClientCheckAppBetaPasswordResponseBetaPassword, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientcheckappbetapasswordresponsebetapassword(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientCheckAppBetaPasswordResponseBetaPassword) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientcheckappbetapasswordresponsebetapassword_unpack(v)? +return i, unpacked +} +pub struct CMsgClientCheckAppBetaPasswordResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +betapasswords []CMsgClientCheckAppBetaPasswordResponseBetaPassword +} +pub fn (o &CMsgClientCheckAppBetaPasswordResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +// [packed=false] +for _, x in o.betapasswords { +res << zzz_vproto_internal_pack_cmsgclientcheckappbetapasswordresponsebetapassword(x, 4) +} + +return res +} + +pub fn cmsgclientcheckappbetapasswordresponse_unpack(buf []byte) ?CMsgClientCheckAppBetaPasswordResponse { +mut res := CMsgClientCheckAppBetaPasswordResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientcheckappbetapasswordresponsebetapassword(cur_buf, tag_wiretype.wire_type)? +res.betapasswords << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientcheckappbetapasswordresponse() CMsgClientCheckAppBetaPasswordResponse { +return CMsgClientCheckAppBetaPasswordResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientcheckappbetapasswordresponse(o CMsgClientCheckAppBetaPasswordResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientcheckappbetapasswordresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientCheckAppBetaPasswordResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientcheckappbetapasswordresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUpdateAppJobReport { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +depot_ids []u32 +app_state u32 +has_app_state bool +job_app_error u32 +has_job_app_error bool +error_details string +has_error_details bool +job_duration u32 +has_job_duration bool +files_validation_failed u32 +has_files_validation_failed bool +job_bytes_downloaded u64 +has_job_bytes_downloaded bool +job_bytes_staged u64 +has_job_bytes_staged bool +bytes_comitted u64 +has_bytes_comitted bool +start_app_state u32 +has_start_app_state bool +stats_machine_id u64 +has_stats_machine_id bool +branch_name string +has_branch_name bool +total_bytes_downloaded u64 +has_total_bytes_downloaded bool +total_bytes_staged u64 +has_total_bytes_staged bool +total_bytes_restored u64 +has_total_bytes_restored bool +is_borrowed bool +has_is_borrowed bool +is_free_weekend bool +has_is_free_weekend bool +total_bytes_legacy u64 +has_total_bytes_legacy bool +total_bytes_patched u64 +has_total_bytes_patched bool +total_bytes_saved u64 +has_total_bytes_saved bool +cell_id u32 +has_cell_id bool +} +pub fn (o &CMsgClientUpdateAppJobReport) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +// [packed=false] +for _, x in o.depot_ids { +res << vproto.pack_uint32_field(x, 2) +} + +if o.has_app_state { +res << vproto.pack_uint32_field(o.app_state, 3) +} + +if o.has_job_app_error { +res << vproto.pack_uint32_field(o.job_app_error, 4) +} + +if o.has_error_details { +res << vproto.pack_string_field(o.error_details, 5) +} + +if o.has_job_duration { +res << vproto.pack_uint32_field(o.job_duration, 6) +} + +if o.has_files_validation_failed { +res << vproto.pack_uint32_field(o.files_validation_failed, 7) +} + +if o.has_job_bytes_downloaded { +res << vproto.pack_uint64_field(o.job_bytes_downloaded, 8) +} + +if o.has_job_bytes_staged { +res << vproto.pack_uint64_field(o.job_bytes_staged, 9) +} + +if o.has_bytes_comitted { +res << vproto.pack_uint64_field(o.bytes_comitted, 10) +} + +if o.has_start_app_state { +res << vproto.pack_uint32_field(o.start_app_state, 11) +} + +if o.has_stats_machine_id { +res << vproto.pack_64bit_field(o.stats_machine_id, 12) +} + +if o.has_branch_name { +res << vproto.pack_string_field(o.branch_name, 13) +} + +if o.has_total_bytes_downloaded { +res << vproto.pack_uint64_field(o.total_bytes_downloaded, 14) +} + +if o.has_total_bytes_staged { +res << vproto.pack_uint64_field(o.total_bytes_staged, 15) +} + +if o.has_total_bytes_restored { +res << vproto.pack_uint64_field(o.total_bytes_restored, 16) +} + +if o.has_is_borrowed { +res << vproto.pack_bool_field(o.is_borrowed, 17) +} + +if o.has_is_free_weekend { +res << vproto.pack_bool_field(o.is_free_weekend, 18) +} + +if o.has_total_bytes_legacy { +res << vproto.pack_uint64_field(o.total_bytes_legacy, 19) +} + +if o.has_total_bytes_patched { +res << vproto.pack_uint64_field(o.total_bytes_patched, 20) +} + +if o.has_total_bytes_saved { +res << vproto.pack_uint64_field(o.total_bytes_saved, 21) +} + +if o.has_cell_id { +res << vproto.pack_uint32_field(o.cell_id, 22) +} + +return res +} + +pub fn cmsgclientupdateappjobreport_unpack(buf []byte) ?CMsgClientUpdateAppJobReport { +mut res := CMsgClientUpdateAppJobReport{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.depot_ids << v +i = ii +} + +3 { +res.has_app_state = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_state = v +i = ii +} + +4 { +res.has_job_app_error = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.job_app_error = v +i = ii +} + +5 { +res.has_error_details = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.error_details = v +i = ii +} + +6 { +res.has_job_duration = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.job_duration = v +i = ii +} + +7 { +res.has_files_validation_failed = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.files_validation_failed = v +i = ii +} + +8 { +res.has_job_bytes_downloaded = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.job_bytes_downloaded = v +i = ii +} + +9 { +res.has_job_bytes_staged = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.job_bytes_staged = v +i = ii +} + +10 { +res.has_bytes_comitted = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.bytes_comitted = v +i = ii +} + +11 { +res.has_start_app_state = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.start_app_state = v +i = ii +} + +12 { +res.has_stats_machine_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.stats_machine_id = v +i = ii +} + +13 { +res.has_branch_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.branch_name = v +i = ii +} + +14 { +res.has_total_bytes_downloaded = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.total_bytes_downloaded = v +i = ii +} + +15 { +res.has_total_bytes_staged = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.total_bytes_staged = v +i = ii +} + +16 { +res.has_total_bytes_restored = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.total_bytes_restored = v +i = ii +} + +17 { +res.has_is_borrowed = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_borrowed = v +i = ii +} + +18 { +res.has_is_free_weekend = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_free_weekend = v +i = ii +} + +19 { +res.has_total_bytes_legacy = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.total_bytes_legacy = v +i = ii +} + +20 { +res.has_total_bytes_patched = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.total_bytes_patched = v +i = ii +} + +21 { +res.has_total_bytes_saved = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.total_bytes_saved = v +i = ii +} + +22 { +res.has_cell_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cell_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientupdateappjobreport() CMsgClientUpdateAppJobReport { +return CMsgClientUpdateAppJobReport{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientupdateappjobreport(o CMsgClientUpdateAppJobReport, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientupdateappjobreport(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUpdateAppJobReport) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientupdateappjobreport_unpack(v)? +return i, unpacked +} +pub struct CMsgClientDPcontentStatsReport { +mut: +unknown_fields []vproto.UnknownField +pub mut: +stats_machine_id u64 +has_stats_machine_id bool +country_code string +has_country_code bool +os_type int +has_os_type bool +language int +has_language bool +num_install_folders u32 +has_num_install_folders bool +num_installed_games u32 +has_num_installed_games bool +size_installed_games u64 +has_size_installed_games bool +} +pub fn (o &CMsgClientDPcontentStatsReport) pack() []byte { +mut res := []byte{} +if o.has_stats_machine_id { +res << vproto.pack_64bit_field(o.stats_machine_id, 1) +} + +if o.has_country_code { +res << vproto.pack_string_field(o.country_code, 2) +} + +if o.has_os_type { +res << vproto.pack_int32_field(o.os_type, 3) +} + +if o.has_language { +res << vproto.pack_int32_field(o.language, 4) +} + +if o.has_num_install_folders { +res << vproto.pack_uint32_field(o.num_install_folders, 5) +} + +if o.has_num_installed_games { +res << vproto.pack_uint32_field(o.num_installed_games, 6) +} + +if o.has_size_installed_games { +res << vproto.pack_uint64_field(o.size_installed_games, 7) +} + +return res +} + +pub fn cmsgclientdpcontentstatsreport_unpack(buf []byte) ?CMsgClientDPcontentStatsReport { +mut res := CMsgClientDPcontentStatsReport{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_stats_machine_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.stats_machine_id = v +i = ii +} + +2 { +res.has_country_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.country_code = v +i = ii +} + +3 { +res.has_os_type = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.os_type = v +i = ii +} + +4 { +res.has_language = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +5 { +res.has_num_install_folders = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.num_install_folders = v +i = ii +} + +6 { +res.has_num_installed_games = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.num_installed_games = v +i = ii +} + +7 { +res.has_size_installed_games = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.size_installed_games = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientdpcontentstatsreport() CMsgClientDPcontentStatsReport { +return CMsgClientDPcontentStatsReport{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientdpcontentstatsreport(o CMsgClientDPcontentStatsReport, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientdpcontentstatsreport(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientDPcontentStatsReport) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientdpcontentstatsreport_unpack(v)? +return i, unpacked +} +pub struct CMsgClientGetCDnauthTokenResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult u32 +has_eresult bool +token string +has_token bool +expiration_time u32 +has_expiration_time bool +} +pub fn (o &CMsgClientGetCDnauthTokenResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_uint32_field(o.eresult, 1) +} + +if o.has_token { +res << vproto.pack_string_field(o.token, 2) +} + +if o.has_expiration_time { +res << vproto.pack_uint32_field(o.expiration_time, 3) +} + +return res +} + +pub fn cmsgclientgetcdnauthtokenresponse_unpack(buf []byte) ?CMsgClientGetCDnauthTokenResponse { +mut res := CMsgClientGetCDnauthTokenResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_token = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.token = v +i = ii +} + +3 { +res.has_expiration_time = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.expiration_time = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientgetcdnauthtokenresponse() CMsgClientGetCDnauthTokenResponse { +return CMsgClientGetCDnauthTokenResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientgetcdnauthtokenresponse(o CMsgClientGetCDnauthTokenResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientgetcdnauthtokenresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientGetCDnauthTokenResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientgetcdnauthtokenresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgDownloadRateStatisticsStatsInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +source_type u32 +has_source_type bool +source_id u32 +has_source_id bool +seconds u32 +has_seconds bool +bytes u64 +has_bytes bool +host_name string +has_host_name bool +microseconds u64 +has_microseconds bool +used_ipv6 bool +has_used_ipv6 bool +proxied bool +has_proxied bool +} +pub fn (o &CMsgDownloadRateStatisticsStatsInfo) pack() []byte { +mut res := []byte{} +if o.has_source_type { +res << vproto.pack_uint32_field(o.source_type, 1) +} + +if o.has_source_id { +res << vproto.pack_uint32_field(o.source_id, 2) +} + +if o.has_seconds { +res << vproto.pack_uint32_field(o.seconds, 3) +} + +if o.has_bytes { +res << vproto.pack_uint64_field(o.bytes, 4) +} + +if o.has_host_name { +res << vproto.pack_string_field(o.host_name, 5) +} + +if o.has_microseconds { +res << vproto.pack_uint64_field(o.microseconds, 6) +} + +if o.has_used_ipv6 { +res << vproto.pack_bool_field(o.used_ipv6, 7) +} + +if o.has_proxied { +res << vproto.pack_bool_field(o.proxied, 8) +} + +return res +} + +pub fn cmsgdownloadratestatisticsstatsinfo_unpack(buf []byte) ?CMsgDownloadRateStatisticsStatsInfo { +mut res := CMsgDownloadRateStatisticsStatsInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_source_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.source_type = v +i = ii +} + +2 { +res.has_source_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.source_id = v +i = ii +} + +3 { +res.has_seconds = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds = v +i = ii +} + +4 { +res.has_bytes = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.bytes = v +i = ii +} + +5 { +res.has_host_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.host_name = v +i = ii +} + +6 { +res.has_microseconds = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.microseconds = v +i = ii +} + +7 { +res.has_used_ipv6 = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.used_ipv6 = v +i = ii +} + +8 { +res.has_proxied = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.proxied = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgdownloadratestatisticsstatsinfo() CMsgDownloadRateStatisticsStatsInfo { +return CMsgDownloadRateStatisticsStatsInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgdownloadratestatisticsstatsinfo(o CMsgDownloadRateStatisticsStatsInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgdownloadratestatisticsstatsinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgDownloadRateStatisticsStatsInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgdownloadratestatisticsstatsinfo_unpack(v)? +return i, unpacked +} +pub struct CMsgDownloadRateStatistics { +mut: +unknown_fields []vproto.UnknownField +pub mut: +cell_id u32 +has_cell_id bool +stats []CMsgDownloadRateStatisticsStatsInfo +throttling_kbps u32 +has_throttling_kbps bool +} +pub fn (o &CMsgDownloadRateStatistics) pack() []byte { +mut res := []byte{} +if o.has_cell_id { +res << vproto.pack_uint32_field(o.cell_id, 1) +} + +// [packed=false] +for _, x in o.stats { +res << zzz_vproto_internal_pack_cmsgdownloadratestatisticsstatsinfo(x, 2) +} + +if o.has_throttling_kbps { +res << vproto.pack_uint32_field(o.throttling_kbps, 3) +} + +return res +} + +pub fn cmsgdownloadratestatistics_unpack(buf []byte) ?CMsgDownloadRateStatistics { +mut res := CMsgDownloadRateStatistics{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_cell_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cell_id = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgdownloadratestatisticsstatsinfo(cur_buf, tag_wiretype.wire_type)? +res.stats << v +i = ii +} + +3 { +res.has_throttling_kbps = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.throttling_kbps = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgdownloadratestatistics() CMsgDownloadRateStatistics { +return CMsgDownloadRateStatistics{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgdownloadratestatistics(o CMsgDownloadRateStatistics, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgdownloadratestatistics(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgDownloadRateStatistics) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgdownloadratestatistics_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRequestAccountData { +mut: +unknown_fields []vproto.UnknownField +pub mut: +account_or_email string +has_account_or_email bool +action u32 +has_action bool +} +pub fn (o &CMsgClientRequestAccountData) pack() []byte { +mut res := []byte{} +if o.has_account_or_email { +res << vproto.pack_string_field(o.account_or_email, 1) +} + +if o.has_action { +res << vproto.pack_uint32_field(o.action, 2) +} + +return res +} + +pub fn cmsgclientrequestaccountdata_unpack(buf []byte) ?CMsgClientRequestAccountData { +mut res := CMsgClientRequestAccountData{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_account_or_email = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.account_or_email = v +i = ii +} + +2 { +res.has_action = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.action = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientrequestaccountdata() CMsgClientRequestAccountData { +return CMsgClientRequestAccountData{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientrequestaccountdata(o CMsgClientRequestAccountData, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientrequestaccountdata(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRequestAccountData) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientrequestaccountdata_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRequestAccountDataResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +action u32 +has_action bool +eresult u32 +has_eresult bool +account_name string +has_account_name bool +ct_matches u32 +has_ct_matches bool +account_name_suggestion1 string +has_account_name_suggestion1 bool +account_name_suggestion2 string +has_account_name_suggestion2 bool +account_name_suggestion3 string +has_account_name_suggestion3 bool +} +pub fn (o &CMsgClientRequestAccountDataResponse) pack() []byte { +mut res := []byte{} +if o.has_action { +res << vproto.pack_uint32_field(o.action, 1) +} + +if o.has_eresult { +res << vproto.pack_uint32_field(o.eresult, 2) +} + +if o.has_account_name { +res << vproto.pack_string_field(o.account_name, 3) +} + +if o.has_ct_matches { +res << vproto.pack_uint32_field(o.ct_matches, 4) +} + +if o.has_account_name_suggestion1 { +res << vproto.pack_string_field(o.account_name_suggestion1, 5) +} + +if o.has_account_name_suggestion2 { +res << vproto.pack_string_field(o.account_name_suggestion2, 6) +} + +if o.has_account_name_suggestion3 { +res << vproto.pack_string_field(o.account_name_suggestion3, 7) +} + +return res +} + +pub fn cmsgclientrequestaccountdataresponse_unpack(buf []byte) ?CMsgClientRequestAccountDataResponse { +mut res := CMsgClientRequestAccountDataResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_action = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.action = v +i = ii +} + +2 { +res.has_eresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +3 { +res.has_account_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.account_name = v +i = ii +} + +4 { +res.has_ct_matches = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ct_matches = v +i = ii +} + +5 { +res.has_account_name_suggestion1 = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.account_name_suggestion1 = v +i = ii +} + +6 { +res.has_account_name_suggestion2 = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.account_name_suggestion2 = v +i = ii +} + +7 { +res.has_account_name_suggestion3 = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.account_name_suggestion3 = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientrequestaccountdataresponse() CMsgClientRequestAccountDataResponse { +return CMsgClientRequestAccountDataResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientrequestaccountdataresponse(o CMsgClientRequestAccountDataResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientrequestaccountdataresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRequestAccountDataResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientrequestaccountdataresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUGsgetGlobalStats { +mut: +unknown_fields []vproto.UnknownField +pub mut: +gameid u64 +has_gameid bool +history_days_requested u32 +has_history_days_requested bool +time_last_requested u32 +has_time_last_requested bool +first_day_cached u32 +has_first_day_cached bool +days_cached u32 +has_days_cached bool +} +pub fn (o &CMsgClientUGsgetGlobalStats) pack() []byte { +mut res := []byte{} +if o.has_gameid { +res << vproto.pack_uint64_field(o.gameid, 1) +} + +if o.has_history_days_requested { +res << vproto.pack_uint32_field(o.history_days_requested, 2) +} + +if o.has_time_last_requested { +res << vproto.pack_32bit_field(o.time_last_requested, 3) +} + +if o.has_first_day_cached { +res << vproto.pack_uint32_field(o.first_day_cached, 4) +} + +if o.has_days_cached { +res << vproto.pack_uint32_field(o.days_cached, 5) +} + +return res +} + +pub fn cmsgclientugsgetglobalstats_unpack(buf []byte) ?CMsgClientUGsgetGlobalStats { +mut res := CMsgClientUGsgetGlobalStats{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_gameid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.gameid = v +i = ii +} + +2 { +res.has_history_days_requested = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.history_days_requested = v +i = ii +} + +3 { +res.has_time_last_requested = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.time_last_requested = v +i = ii +} + +4 { +res.has_first_day_cached = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.first_day_cached = v +i = ii +} + +5 { +res.has_days_cached = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.days_cached = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientugsgetglobalstats() CMsgClientUGsgetGlobalStats { +return CMsgClientUGsgetGlobalStats{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientugsgetglobalstats(o CMsgClientUGsgetGlobalStats, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientugsgetglobalstats(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUGsgetGlobalStats) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientugsgetglobalstats_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUGsgetGlobalStatsResponseDayStat { +mut: +unknown_fields []vproto.UnknownField +pub mut: +stat_id int +has_stat_id bool +data i64 +has_data bool +} +pub fn (o &CMsgClientUGsgetGlobalStatsResponseDayStat) pack() []byte { +mut res := []byte{} +if o.has_stat_id { +res << vproto.pack_int32_field(o.stat_id, 1) +} + +if o.has_data { +res << vproto.pack_int64_field(o.data, 2) +} + +return res +} + +pub fn cmsgclientugsgetglobalstatsresponsedaystat_unpack(buf []byte) ?CMsgClientUGsgetGlobalStatsResponseDayStat { +mut res := CMsgClientUGsgetGlobalStatsResponseDayStat{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_stat_id = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.stat_id = v +i = ii +} + +2 { +res.has_data = true +ii, v := vproto.unpack_int64_field(cur_buf, tag_wiretype.wire_type)? +res.data = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientugsgetglobalstatsresponsedaystat() CMsgClientUGsgetGlobalStatsResponseDayStat { +return CMsgClientUGsgetGlobalStatsResponseDayStat{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientugsgetglobalstatsresponsedaystat(o CMsgClientUGsgetGlobalStatsResponseDayStat, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientugsgetglobalstatsresponsedaystat(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUGsgetGlobalStatsResponseDayStat) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientugsgetglobalstatsresponsedaystat_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUGsgetGlobalStatsResponseDay { +mut: +unknown_fields []vproto.UnknownField +pub mut: +day_id u32 +has_day_id bool +stats []CMsgClientUGsgetGlobalStatsResponseDayStat +} +pub fn (o &CMsgClientUGsgetGlobalStatsResponseDay) pack() []byte { +mut res := []byte{} +if o.has_day_id { +res << vproto.pack_uint32_field(o.day_id, 1) +} + +// [packed=false] +for _, x in o.stats { +res << zzz_vproto_internal_pack_cmsgclientugsgetglobalstatsresponsedaystat(x, 2) +} + +return res +} + +pub fn cmsgclientugsgetglobalstatsresponseday_unpack(buf []byte) ?CMsgClientUGsgetGlobalStatsResponseDay { +mut res := CMsgClientUGsgetGlobalStatsResponseDay{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_day_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.day_id = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientugsgetglobalstatsresponsedaystat(cur_buf, tag_wiretype.wire_type)? +res.stats << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientugsgetglobalstatsresponseday() CMsgClientUGsgetGlobalStatsResponseDay { +return CMsgClientUGsgetGlobalStatsResponseDay{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientugsgetglobalstatsresponseday(o CMsgClientUGsgetGlobalStatsResponseDay, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientugsgetglobalstatsresponseday(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUGsgetGlobalStatsResponseDay) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientugsgetglobalstatsresponseday_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUGsgetGlobalStatsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +timestamp u32 +has_timestamp bool +day_current int +has_day_current bool +days []CMsgClientUGsgetGlobalStatsResponseDay +} +pub fn (o &CMsgClientUGsgetGlobalStatsResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_timestamp { +res << vproto.pack_32bit_field(o.timestamp, 2) +} + +if o.has_day_current { +res << vproto.pack_int32_field(o.day_current, 3) +} + +// [packed=false] +for _, x in o.days { +res << zzz_vproto_internal_pack_cmsgclientugsgetglobalstatsresponseday(x, 4) +} + +return res +} + +pub fn cmsgclientugsgetglobalstatsresponse_unpack(buf []byte) ?CMsgClientUGsgetGlobalStatsResponse { +mut res := CMsgClientUGsgetGlobalStatsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_timestamp = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp = v +i = ii +} + +3 { +res.has_day_current = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.day_current = v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientugsgetglobalstatsresponseday(cur_buf, tag_wiretype.wire_type)? +res.days << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientugsgetglobalstatsresponse() CMsgClientUGsgetGlobalStatsResponse { +return CMsgClientUGsgetGlobalStatsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientugsgetglobalstatsresponse(o CMsgClientUGsgetGlobalStatsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientugsgetglobalstatsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUGsgetGlobalStatsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientugsgetglobalstatsresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgGameServerDataPlayer { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id u64 +has_steam_id bool +} +pub fn (o &CMsgGameServerDataPlayer) pack() []byte { +mut res := []byte{} +if o.has_steam_id { +res << vproto.pack_64bit_field(o.steam_id, 1) +} + +return res +} + +pub fn cmsggameserverdataplayer_unpack(buf []byte) ?CMsgGameServerDataPlayer { +mut res := CMsgGameServerDataPlayer{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggameserverdataplayer() CMsgGameServerDataPlayer { +return CMsgGameServerDataPlayer{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggameserverdataplayer(o CMsgGameServerDataPlayer, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggameserverdataplayer(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGameServerDataPlayer) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggameserverdataplayer_unpack(v)? +return i, unpacked +} +pub struct CMsgGameServerData { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id_gs u64 +has_steam_id_gs bool +deprecated_ip u32 +has_deprecated_ip bool +query_port u32 +has_query_port bool +game_port u32 +has_game_port bool +sourcetv_port u32 +has_sourcetv_port bool +name string +has_name bool +game_ip_address CMsgIPaddress +has_game_ip_address bool +app_id u32 +has_app_id bool +gamedir string +has_gamedir bool +version string +has_version bool +product string +has_product bool +region string +has_region bool +players []CMsgGameServerDataPlayer +max_players u32 +has_max_players bool +bot_count u32 +has_bot_count bool +password bool +has_password bool +secure bool +has_secure bool +dedicated bool +has_dedicated bool +os string +has_os bool +game_data string +has_game_data bool +game_data_version u32 +has_game_data_version bool +game_type string +has_game_type bool +map string +has_map bool +} +pub fn (o &CMsgGameServerData) pack() []byte { +mut res := []byte{} +if o.has_steam_id_gs { +res << vproto.pack_64bit_field(o.steam_id_gs, 1) +} + +if o.has_deprecated_ip { +res << vproto.pack_uint32_field(o.deprecated_ip, 2) +} + +if o.has_query_port { +res << vproto.pack_uint32_field(o.query_port, 3) +} + +if o.has_game_port { +res << vproto.pack_uint32_field(o.game_port, 4) +} + +if o.has_sourcetv_port { +res << vproto.pack_uint32_field(o.sourcetv_port, 5) +} + +if o.has_name { +res << vproto.pack_string_field(o.name, 22) +} + +if o.has_game_ip_address { +res << zzz_vproto_internal_pack_cmsgipaddress(o.game_ip_address, 23) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 6) +} + +if o.has_gamedir { +res << vproto.pack_string_field(o.gamedir, 7) +} + +if o.has_version { +res << vproto.pack_string_field(o.version, 8) +} + +if o.has_product { +res << vproto.pack_string_field(o.product, 9) +} + +if o.has_region { +res << vproto.pack_string_field(o.region, 10) +} + +// [packed=false] +for _, x in o.players { +res << zzz_vproto_internal_pack_cmsggameserverdataplayer(x, 11) +} + +if o.has_max_players { +res << vproto.pack_uint32_field(o.max_players, 12) +} + +if o.has_bot_count { +res << vproto.pack_uint32_field(o.bot_count, 13) +} + +if o.has_password { +res << vproto.pack_bool_field(o.password, 14) +} + +if o.has_secure { +res << vproto.pack_bool_field(o.secure, 15) +} + +if o.has_dedicated { +res << vproto.pack_bool_field(o.dedicated, 16) +} + +if o.has_os { +res << vproto.pack_string_field(o.os, 17) +} + +if o.has_game_data { +res << vproto.pack_string_field(o.game_data, 18) +} + +if o.has_game_data_version { +res << vproto.pack_uint32_field(o.game_data_version, 19) +} + +if o.has_game_type { +res << vproto.pack_string_field(o.game_type, 20) +} + +if o.has_map { +res << vproto.pack_string_field(o.map, 21) +} + +return res +} + +pub fn cmsggameserverdata_unpack(buf []byte) ?CMsgGameServerData { +mut res := CMsgGameServerData{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id_gs = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_gs = v +i = ii +} + +2 { +res.has_deprecated_ip = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated_ip = v +i = ii +} + +3 { +res.has_query_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.query_port = v +i = ii +} + +4 { +res.has_game_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.game_port = v +i = ii +} + +5 { +res.has_sourcetv_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.sourcetv_port = v +i = ii +} + +22 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +23 { +res.has_game_ip_address = true +ii, v := zzz_vproto_internal_unpack_cmsgipaddress(cur_buf, tag_wiretype.wire_type)? +res.game_ip_address = v +i = ii +} + +6 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +7 { +res.has_gamedir = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.gamedir = v +i = ii +} + +8 { +res.has_version = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.version = v +i = ii +} + +9 { +res.has_product = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.product = v +i = ii +} + +10 { +res.has_region = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.region = v +i = ii +} + +11 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsggameserverdataplayer(cur_buf, tag_wiretype.wire_type)? +res.players << v +i = ii +} + +12 { +res.has_max_players = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.max_players = v +i = ii +} + +13 { +res.has_bot_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.bot_count = v +i = ii +} + +14 { +res.has_password = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.password = v +i = ii +} + +15 { +res.has_secure = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.secure = v +i = ii +} + +16 { +res.has_dedicated = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.dedicated = v +i = ii +} + +17 { +res.has_os = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.os = v +i = ii +} + +18 { +res.has_game_data = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.game_data = v +i = ii +} + +19 { +res.has_game_data_version = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.game_data_version = v +i = ii +} + +20 { +res.has_game_type = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.game_type = v +i = ii +} + +21 { +res.has_map = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.map = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggameserverdata() CMsgGameServerData { +return CMsgGameServerData{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggameserverdata(o CMsgGameServerData, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggameserverdata(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGameServerData) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggameserverdata_unpack(v)? +return i, unpacked +} +pub struct CMsgGameServerRemove { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id u64 +has_steam_id bool +deprecated_ip u32 +has_deprecated_ip bool +query_port u32 +has_query_port bool +ip CMsgIPaddress +has_ip bool +} +pub fn (o &CMsgGameServerRemove) pack() []byte { +mut res := []byte{} +if o.has_steam_id { +res << vproto.pack_64bit_field(o.steam_id, 1) +} + +if o.has_deprecated_ip { +res << vproto.pack_uint32_field(o.deprecated_ip, 2) +} + +if o.has_query_port { +res << vproto.pack_uint32_field(o.query_port, 3) +} + +if o.has_ip { +res << zzz_vproto_internal_pack_cmsgipaddress(o.ip, 4) +} + +return res +} + +pub fn cmsggameserverremove_unpack(buf []byte) ?CMsgGameServerRemove { +mut res := CMsgGameServerRemove{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id = v +i = ii +} + +2 { +res.has_deprecated_ip = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated_ip = v +i = ii +} + +3 { +res.has_query_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.query_port = v +i = ii +} + +4 { +res.has_ip = true +ii, v := zzz_vproto_internal_unpack_cmsgipaddress(cur_buf, tag_wiretype.wire_type)? +res.ip = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggameserverremove() CMsgGameServerRemove { +return CMsgGameServerRemove{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggameserverremove(o CMsgGameServerRemove, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggameserverremove(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGameServerRemove) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggameserverremove_unpack(v)? +return i, unpacked +} +pub struct CMsgClientGMsserverQuery { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +geo_location_ip u32 +has_geo_location_ip bool +region_code u32 +has_region_code bool +filter_text string +has_filter_text bool +max_servers u32 +has_max_servers bool +} +pub fn (o &CMsgClientGMsserverQuery) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_geo_location_ip { +res << vproto.pack_uint32_field(o.geo_location_ip, 2) +} + +if o.has_region_code { +res << vproto.pack_uint32_field(o.region_code, 3) +} + +if o.has_filter_text { +res << vproto.pack_string_field(o.filter_text, 4) +} + +if o.has_max_servers { +res << vproto.pack_uint32_field(o.max_servers, 5) +} + +return res +} + +pub fn cmsgclientgmsserverquery_unpack(buf []byte) ?CMsgClientGMsserverQuery { +mut res := CMsgClientGMsserverQuery{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_geo_location_ip = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.geo_location_ip = v +i = ii +} + +3 { +res.has_region_code = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.region_code = v +i = ii +} + +4 { +res.has_filter_text = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.filter_text = v +i = ii +} + +5 { +res.has_max_servers = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.max_servers = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientgmsserverquery() CMsgClientGMsserverQuery { +return CMsgClientGMsserverQuery{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientgmsserverquery(o CMsgClientGMsserverQuery, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientgmsserverquery(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientGMsserverQuery) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientgmsserverquery_unpack(v)? +return i, unpacked +} +pub struct CMsgGMsclientServerQueryResponseServer { +mut: +unknown_fields []vproto.UnknownField +pub mut: +deprecated_server_ip u32 +has_deprecated_server_ip bool +server_port u32 +has_server_port bool +auth_players u32 +has_auth_players bool +server_ip CMsgIPaddress +has_server_ip bool +} +pub fn (o &CMsgGMsclientServerQueryResponseServer) pack() []byte { +mut res := []byte{} +if o.has_deprecated_server_ip { +res << vproto.pack_uint32_field(o.deprecated_server_ip, 1) +} + +if o.has_server_port { +res << vproto.pack_uint32_field(o.server_port, 2) +} + +if o.has_auth_players { +res << vproto.pack_uint32_field(o.auth_players, 3) +} + +if o.has_server_ip { +res << zzz_vproto_internal_pack_cmsgipaddress(o.server_ip, 4) +} + +return res +} + +pub fn cmsggmsclientserverqueryresponseserver_unpack(buf []byte) ?CMsgGMsclientServerQueryResponseServer { +mut res := CMsgGMsclientServerQueryResponseServer{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_deprecated_server_ip = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated_server_ip = v +i = ii +} + +2 { +res.has_server_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.server_port = v +i = ii +} + +3 { +res.has_auth_players = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.auth_players = v +i = ii +} + +4 { +res.has_server_ip = true +ii, v := zzz_vproto_internal_unpack_cmsgipaddress(cur_buf, tag_wiretype.wire_type)? +res.server_ip = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggmsclientserverqueryresponseserver() CMsgGMsclientServerQueryResponseServer { +return CMsgGMsclientServerQueryResponseServer{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggmsclientserverqueryresponseserver(o CMsgGMsclientServerQueryResponseServer, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggmsclientserverqueryresponseserver(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGMsclientServerQueryResponseServer) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggmsclientserverqueryresponseserver_unpack(v)? +return i, unpacked +} +pub struct CMsgGMsclientServerQueryResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +servers []CMsgGMsclientServerQueryResponseServer +error string +has_error bool +} +pub fn (o &CMsgGMsclientServerQueryResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.servers { +res << zzz_vproto_internal_pack_cmsggmsclientserverqueryresponseserver(x, 1) +} + +if o.has_error { +res << vproto.pack_string_field(o.error, 2) +} + +return res +} + +pub fn cmsggmsclientserverqueryresponse_unpack(buf []byte) ?CMsgGMsclientServerQueryResponse { +mut res := CMsgGMsclientServerQueryResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsggmsclientserverqueryresponseserver(cur_buf, tag_wiretype.wire_type)? +res.servers << v +i = ii +} + +2 { +res.has_error = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.error = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggmsclientserverqueryresponse() CMsgGMsclientServerQueryResponse { +return CMsgGMsclientServerQueryResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggmsclientserverqueryresponse(o CMsgGMsclientServerQueryResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggmsclientserverqueryresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGMsclientServerQueryResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggmsclientserverqueryresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgGameServerOutOfDate { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id_gs u64 +has_steam_id_gs bool +reject bool +has_reject bool +message string +has_message bool +} +pub fn (o &CMsgGameServerOutOfDate) pack() []byte { +mut res := []byte{} +if o.has_steam_id_gs { +res << vproto.pack_64bit_field(o.steam_id_gs, 1) +} + +if o.has_reject { +res << vproto.pack_bool_field(o.reject, 2) +} + +if o.has_message { +res << vproto.pack_string_field(o.message, 3) +} + +return res +} + +pub fn cmsggameserveroutofdate_unpack(buf []byte) ?CMsgGameServerOutOfDate { +mut res := CMsgGameServerOutOfDate{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id_gs = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_gs = v +i = ii +} + +2 { +res.has_reject = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.reject = v +i = ii +} + +3 { +res.has_message = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.message = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggameserveroutofdate() CMsgGameServerOutOfDate { +return CMsgGameServerOutOfDate{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggameserveroutofdate(o CMsgGameServerOutOfDate, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggameserveroutofdate(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGameServerOutOfDate) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggameserveroutofdate_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRedeemGuestPass { +mut: +unknown_fields []vproto.UnknownField +pub mut: +guest_pass_id u64 +has_guest_pass_id bool +} +pub fn (o &CMsgClientRedeemGuestPass) pack() []byte { +mut res := []byte{} +if o.has_guest_pass_id { +res << vproto.pack_64bit_field(o.guest_pass_id, 1) +} + +return res +} + +pub fn cmsgclientredeemguestpass_unpack(buf []byte) ?CMsgClientRedeemGuestPass { +mut res := CMsgClientRedeemGuestPass{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_guest_pass_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.guest_pass_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientredeemguestpass() CMsgClientRedeemGuestPass { +return CMsgClientRedeemGuestPass{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientredeemguestpass(o CMsgClientRedeemGuestPass, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientredeemguestpass(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRedeemGuestPass) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientredeemguestpass_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRedeemGuestPassResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult u32 +has_eresult bool +package_id u32 +has_package_id bool +must_own_appid u32 +has_must_own_appid bool +} +pub fn (o &CMsgClientRedeemGuestPassResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_uint32_field(o.eresult, 1) +} + +if o.has_package_id { +res << vproto.pack_uint32_field(o.package_id, 2) +} + +if o.has_must_own_appid { +res << vproto.pack_uint32_field(o.must_own_appid, 3) +} + +return res +} + +pub fn cmsgclientredeemguestpassresponse_unpack(buf []byte) ?CMsgClientRedeemGuestPassResponse { +mut res := CMsgClientRedeemGuestPassResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_package_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.package_id = v +i = ii +} + +3 { +res.has_must_own_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.must_own_appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientredeemguestpassresponse() CMsgClientRedeemGuestPassResponse { +return CMsgClientRedeemGuestPassResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientredeemguestpassresponse(o CMsgClientRedeemGuestPassResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientredeemguestpassresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRedeemGuestPassResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientredeemguestpassresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientGetClanActivityCounts { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid_clans []u64 +} +pub fn (o &CMsgClientGetClanActivityCounts) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.steamid_clans { +res << vproto.pack_uint64_field(x, 1) +} + +return res +} + +pub fn cmsgclientgetclanactivitycounts_unpack(buf []byte) ?CMsgClientGetClanActivityCounts { +mut res := CMsgClientGetClanActivityCounts{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_clans << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientgetclanactivitycounts() CMsgClientGetClanActivityCounts { +return CMsgClientGetClanActivityCounts{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientgetclanactivitycounts(o CMsgClientGetClanActivityCounts, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientgetclanactivitycounts(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientGetClanActivityCounts) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientgetclanactivitycounts_unpack(v)? +return i, unpacked +} +pub struct CMsgClientGetClanActivityCountsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult u32 +has_eresult bool +} +pub fn (o &CMsgClientGetClanActivityCountsResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_uint32_field(o.eresult, 1) +} + +return res +} + +pub fn cmsgclientgetclanactivitycountsresponse_unpack(buf []byte) ?CMsgClientGetClanActivityCountsResponse { +mut res := CMsgClientGetClanActivityCountsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientgetclanactivitycountsresponse() CMsgClientGetClanActivityCountsResponse { +return CMsgClientGetClanActivityCountsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientgetclanactivitycountsresponse(o CMsgClientGetClanActivityCountsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientgetclanactivitycountsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientGetClanActivityCountsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientgetclanactivitycountsresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientOGsreportString { +mut: +unknown_fields []vproto.UnknownField +pub mut: +accumulated bool +has_accumulated bool +sessionid u64 +has_sessionid bool +severity int +has_severity bool +formatter string +has_formatter bool +varargs []byte +has_varargs bool +} +pub fn (o &CMsgClientOGsreportString) pack() []byte { +mut res := []byte{} +if o.has_accumulated { +res << vproto.pack_bool_field(o.accumulated, 1) +} + +if o.has_sessionid { +res << vproto.pack_uint64_field(o.sessionid, 2) +} + +if o.has_severity { +res << vproto.pack_int32_field(o.severity, 3) +} + +if o.has_formatter { +res << vproto.pack_string_field(o.formatter, 4) +} + +if o.has_varargs { +res << vproto.pack_bytes_field(o.varargs, 5) +} + +return res +} + +pub fn cmsgclientogsreportstring_unpack(buf []byte) ?CMsgClientOGsreportString { +mut res := CMsgClientOGsreportString{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_accumulated = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.accumulated = v +i = ii +} + +2 { +res.has_sessionid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.sessionid = v +i = ii +} + +3 { +res.has_severity = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.severity = v +i = ii +} + +4 { +res.has_formatter = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.formatter = v +i = ii +} + +5 { +res.has_varargs = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.varargs = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientogsreportstring() CMsgClientOGsreportString { +return CMsgClientOGsreportString{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientogsreportstring(o CMsgClientOGsreportString, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientogsreportstring(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientOGsreportString) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientogsreportstring_unpack(v)? +return i, unpacked +} +pub struct CMsgClientOGsreportBug { +mut: +unknown_fields []vproto.UnknownField +pub mut: +sessionid u64 +has_sessionid bool +bugtext string +has_bugtext bool +screenshot []byte +has_screenshot bool +} +pub fn (o &CMsgClientOGsreportBug) pack() []byte { +mut res := []byte{} +if o.has_sessionid { +res << vproto.pack_uint64_field(o.sessionid, 1) +} + +if o.has_bugtext { +res << vproto.pack_string_field(o.bugtext, 2) +} + +if o.has_screenshot { +res << vproto.pack_bytes_field(o.screenshot, 3) +} + +return res +} + +pub fn cmsgclientogsreportbug_unpack(buf []byte) ?CMsgClientOGsreportBug { +mut res := CMsgClientOGsreportBug{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_sessionid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.sessionid = v +i = ii +} + +2 { +res.has_bugtext = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.bugtext = v +i = ii +} + +3 { +res.has_screenshot = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.screenshot = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientogsreportbug() CMsgClientOGsreportBug { +return CMsgClientOGsreportBug{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientogsreportbug(o CMsgClientOGsreportBug, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientogsreportbug(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientOGsreportBug) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientogsreportbug_unpack(v)? +return i, unpacked +} +pub struct CMsgGSassociateWithClan { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id_clan u64 +has_steam_id_clan bool +} +pub fn (o &CMsgGSassociateWithClan) pack() []byte { +mut res := []byte{} +if o.has_steam_id_clan { +res << vproto.pack_64bit_field(o.steam_id_clan, 1) +} + +return res +} + +pub fn cmsggsassociatewithclan_unpack(buf []byte) ?CMsgGSassociateWithClan { +mut res := CMsgGSassociateWithClan{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id_clan = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_clan = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggsassociatewithclan() CMsgGSassociateWithClan { +return CMsgGSassociateWithClan{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggsassociatewithclan(o CMsgGSassociateWithClan, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggsassociatewithclan(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGSassociateWithClan) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggsassociatewithclan_unpack(v)? +return i, unpacked +} +pub struct CMsgGSassociateWithClanResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id_clan u64 +has_steam_id_clan bool +eresult u32 +has_eresult bool +} +pub fn (o &CMsgGSassociateWithClanResponse) pack() []byte { +mut res := []byte{} +if o.has_steam_id_clan { +res << vproto.pack_64bit_field(o.steam_id_clan, 1) +} + +if o.has_eresult { +res << vproto.pack_uint32_field(o.eresult, 2) +} + +return res +} + +pub fn cmsggsassociatewithclanresponse_unpack(buf []byte) ?CMsgGSassociateWithClanResponse { +mut res := CMsgGSassociateWithClanResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id_clan = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_clan = v +i = ii +} + +2 { +res.has_eresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggsassociatewithclanresponse() CMsgGSassociateWithClanResponse { +return CMsgGSassociateWithClanResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggsassociatewithclanresponse(o CMsgGSassociateWithClanResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggsassociatewithclanresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGSassociateWithClanResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggsassociatewithclanresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgGScomputeNewPlayerCompatibility { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id_candidate u64 +has_steam_id_candidate bool +} +pub fn (o &CMsgGScomputeNewPlayerCompatibility) pack() []byte { +mut res := []byte{} +if o.has_steam_id_candidate { +res << vproto.pack_64bit_field(o.steam_id_candidate, 1) +} + +return res +} + +pub fn cmsggscomputenewplayercompatibility_unpack(buf []byte) ?CMsgGScomputeNewPlayerCompatibility { +mut res := CMsgGScomputeNewPlayerCompatibility{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id_candidate = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_candidate = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggscomputenewplayercompatibility() CMsgGScomputeNewPlayerCompatibility { +return CMsgGScomputeNewPlayerCompatibility{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggscomputenewplayercompatibility(o CMsgGScomputeNewPlayerCompatibility, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggscomputenewplayercompatibility(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGScomputeNewPlayerCompatibility) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggscomputenewplayercompatibility_unpack(v)? +return i, unpacked +} +pub struct CMsgGScomputeNewPlayerCompatibilityResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id_candidate u64 +has_steam_id_candidate bool +eresult u32 +has_eresult bool +is_clan_member bool +has_is_clan_member bool +ct_dont_like_you int +has_ct_dont_like_you bool +ct_you_dont_like int +has_ct_you_dont_like bool +ct_clanmembers_dont_like_you int +has_ct_clanmembers_dont_like_you bool +} +pub fn (o &CMsgGScomputeNewPlayerCompatibilityResponse) pack() []byte { +mut res := []byte{} +if o.has_steam_id_candidate { +res << vproto.pack_64bit_field(o.steam_id_candidate, 1) +} + +if o.has_eresult { +res << vproto.pack_uint32_field(o.eresult, 2) +} + +if o.has_is_clan_member { +res << vproto.pack_bool_field(o.is_clan_member, 3) +} + +if o.has_ct_dont_like_you { +res << vproto.pack_int32_field(o.ct_dont_like_you, 4) +} + +if o.has_ct_you_dont_like { +res << vproto.pack_int32_field(o.ct_you_dont_like, 5) +} + +if o.has_ct_clanmembers_dont_like_you { +res << vproto.pack_int32_field(o.ct_clanmembers_dont_like_you, 6) +} + +return res +} + +pub fn cmsggscomputenewplayercompatibilityresponse_unpack(buf []byte) ?CMsgGScomputeNewPlayerCompatibilityResponse { +mut res := CMsgGScomputeNewPlayerCompatibilityResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id_candidate = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_candidate = v +i = ii +} + +2 { +res.has_eresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +3 { +res.has_is_clan_member = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_clan_member = v +i = ii +} + +4 { +res.has_ct_dont_like_you = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.ct_dont_like_you = v +i = ii +} + +5 { +res.has_ct_you_dont_like = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.ct_you_dont_like = v +i = ii +} + +6 { +res.has_ct_clanmembers_dont_like_you = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.ct_clanmembers_dont_like_you = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggscomputenewplayercompatibilityresponse() CMsgGScomputeNewPlayerCompatibilityResponse { +return CMsgGScomputeNewPlayerCompatibilityResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggscomputenewplayercompatibilityresponse(o CMsgGScomputeNewPlayerCompatibilityResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggscomputenewplayercompatibilityresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGScomputeNewPlayerCompatibilityResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggscomputenewplayercompatibilityresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientSentLogs { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CMsgClientSentLogs) pack() []byte { +res := []byte{} +return res +} + +pub fn cmsgclientsentlogs_unpack(buf []byte) ?CMsgClientSentLogs { +res := CMsgClientSentLogs{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientsentlogs() CMsgClientSentLogs { +return CMsgClientSentLogs{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientsentlogs(o CMsgClientSentLogs, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientsentlogs(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientSentLogs) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientsentlogs_unpack(v)? +return i, unpacked +} +pub struct CMsgGCclient { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +msgtype u32 +has_msgtype bool +payload []byte +has_payload bool +steamid u64 +has_steamid bool +gcname string +has_gcname bool +ip u32 +has_ip bool +} +pub fn (o &CMsgGCclient) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_msgtype { +res << vproto.pack_uint32_field(o.msgtype, 2) +} + +if o.has_payload { +res << vproto.pack_bytes_field(o.payload, 3) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 4) +} + +if o.has_gcname { +res << vproto.pack_string_field(o.gcname, 5) +} + +if o.has_ip { +res << vproto.pack_uint32_field(o.ip, 6) +} + +return res +} + +pub fn cmsggcclient_unpack(buf []byte) ?CMsgGCclient { +mut res := CMsgGCclient{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_msgtype = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.msgtype = v +i = ii +} + +3 { +res.has_payload = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.payload = v +i = ii +} + +4 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +5 { +res.has_gcname = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.gcname = v +i = ii +} + +6 { +res.has_ip = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ip = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggcclient() CMsgGCclient { +return CMsgGCclient{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggcclient(o CMsgGCclient, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggcclient(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGCclient) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggcclient_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRequestFreeLicense { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appids []u32 +} +pub fn (o &CMsgClientRequestFreeLicense) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.appids { +res << vproto.pack_uint32_field(x, 2) +} + +return res +} + +pub fn cmsgclientrequestfreelicense_unpack(buf []byte) ?CMsgClientRequestFreeLicense { +mut res := CMsgClientRequestFreeLicense{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +2 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientrequestfreelicense() CMsgClientRequestFreeLicense { +return CMsgClientRequestFreeLicense{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientrequestfreelicense(o CMsgClientRequestFreeLicense, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientrequestfreelicense(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRequestFreeLicense) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientrequestfreelicense_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRequestFreeLicenseResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult u32 +has_eresult bool +granted_packageids []u32 +granted_appids []u32 +} +pub fn (o &CMsgClientRequestFreeLicenseResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_uint32_field(o.eresult, 1) +} + +// [packed=false] +for _, x in o.granted_packageids { +res << vproto.pack_uint32_field(x, 2) +} + +// [packed=false] +for _, x in o.granted_appids { +res << vproto.pack_uint32_field(x, 3) +} + +return res +} + +pub fn cmsgclientrequestfreelicenseresponse_unpack(buf []byte) ?CMsgClientRequestFreeLicenseResponse { +mut res := CMsgClientRequestFreeLicenseResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.granted_packageids << v +i = ii +} + +3 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.granted_appids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientrequestfreelicenseresponse() CMsgClientRequestFreeLicenseResponse { +return CMsgClientRequestFreeLicenseResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientrequestfreelicenseresponse(o CMsgClientRequestFreeLicenseResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientrequestfreelicenseresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRequestFreeLicenseResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientrequestfreelicenseresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgDRmdownloadRequestWithCrashData { +mut: +unknown_fields []vproto.UnknownField +pub mut: +download_flags u32 +has_download_flags bool +download_types_known u32 +has_download_types_known bool +guid_drm []byte +has_guid_drm bool +guid_split []byte +has_guid_split bool +guid_merge []byte +has_guid_merge bool +module_name string +has_module_name bool +module_path string +has_module_path bool +crash_data []byte +has_crash_data bool +} +pub fn (o &CMsgDRmdownloadRequestWithCrashData) pack() []byte { +mut res := []byte{} +if o.has_download_flags { +res << vproto.pack_uint32_field(o.download_flags, 1) +} + +if o.has_download_types_known { +res << vproto.pack_uint32_field(o.download_types_known, 2) +} + +if o.has_guid_drm { +res << vproto.pack_bytes_field(o.guid_drm, 3) +} + +if o.has_guid_split { +res << vproto.pack_bytes_field(o.guid_split, 4) +} + +if o.has_guid_merge { +res << vproto.pack_bytes_field(o.guid_merge, 5) +} + +if o.has_module_name { +res << vproto.pack_string_field(o.module_name, 6) +} + +if o.has_module_path { +res << vproto.pack_string_field(o.module_path, 7) +} + +if o.has_crash_data { +res << vproto.pack_bytes_field(o.crash_data, 8) +} + +return res +} + +pub fn cmsgdrmdownloadrequestwithcrashdata_unpack(buf []byte) ?CMsgDRmdownloadRequestWithCrashData { +mut res := CMsgDRmdownloadRequestWithCrashData{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_download_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.download_flags = v +i = ii +} + +2 { +res.has_download_types_known = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.download_types_known = v +i = ii +} + +3 { +res.has_guid_drm = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.guid_drm = v +i = ii +} + +4 { +res.has_guid_split = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.guid_split = v +i = ii +} + +5 { +res.has_guid_merge = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.guid_merge = v +i = ii +} + +6 { +res.has_module_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.module_name = v +i = ii +} + +7 { +res.has_module_path = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.module_path = v +i = ii +} + +8 { +res.has_crash_data = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.crash_data = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgdrmdownloadrequestwithcrashdata() CMsgDRmdownloadRequestWithCrashData { +return CMsgDRmdownloadRequestWithCrashData{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgdrmdownloadrequestwithcrashdata(o CMsgDRmdownloadRequestWithCrashData, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgdrmdownloadrequestwithcrashdata(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgDRmdownloadRequestWithCrashData) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgdrmdownloadrequestwithcrashdata_unpack(v)? +return i, unpacked +} +pub struct CMsgDRmdownloadResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult u32 +has_eresult bool +app_id u32 +has_app_id bool +blob_download_type u32 +has_blob_download_type bool +merge_guid []byte +has_merge_guid bool +download_file_dfs_ip u32 +has_download_file_dfs_ip bool +download_file_dfs_port u32 +has_download_file_dfs_port bool +download_file_url string +has_download_file_url bool +module_path string +has_module_path bool +} +pub fn (o &CMsgDRmdownloadResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_uint32_field(o.eresult, 1) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 2) +} + +if o.has_blob_download_type { +res << vproto.pack_uint32_field(o.blob_download_type, 3) +} + +if o.has_merge_guid { +res << vproto.pack_bytes_field(o.merge_guid, 4) +} + +if o.has_download_file_dfs_ip { +res << vproto.pack_uint32_field(o.download_file_dfs_ip, 5) +} + +if o.has_download_file_dfs_port { +res << vproto.pack_uint32_field(o.download_file_dfs_port, 6) +} + +if o.has_download_file_url { +res << vproto.pack_string_field(o.download_file_url, 7) +} + +if o.has_module_path { +res << vproto.pack_string_field(o.module_path, 8) +} + +return res +} + +pub fn cmsgdrmdownloadresponse_unpack(buf []byte) ?CMsgDRmdownloadResponse { +mut res := CMsgDRmdownloadResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +3 { +res.has_blob_download_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.blob_download_type = v +i = ii +} + +4 { +res.has_merge_guid = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.merge_guid = v +i = ii +} + +5 { +res.has_download_file_dfs_ip = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.download_file_dfs_ip = v +i = ii +} + +6 { +res.has_download_file_dfs_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.download_file_dfs_port = v +i = ii +} + +7 { +res.has_download_file_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.download_file_url = v +i = ii +} + +8 { +res.has_module_path = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.module_path = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgdrmdownloadresponse() CMsgDRmdownloadResponse { +return CMsgDRmdownloadResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgdrmdownloadresponse(o CMsgDRmdownloadResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgdrmdownloadresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgDRmdownloadResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgdrmdownloadresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgDRmfinalResult { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult u32 +has_eresult bool +app_id u32 +has_app_id bool +blob_download_type u32 +has_blob_download_type bool +error_detail u32 +has_error_detail bool +merge_guid []byte +has_merge_guid bool +download_file_dfs_ip u32 +has_download_file_dfs_ip bool +download_file_dfs_port u32 +has_download_file_dfs_port bool +download_file_url string +has_download_file_url bool +} +pub fn (o &CMsgDRmfinalResult) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_uint32_field(o.eresult, 1) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 2) +} + +if o.has_blob_download_type { +res << vproto.pack_uint32_field(o.blob_download_type, 3) +} + +if o.has_error_detail { +res << vproto.pack_uint32_field(o.error_detail, 4) +} + +if o.has_merge_guid { +res << vproto.pack_bytes_field(o.merge_guid, 5) +} + +if o.has_download_file_dfs_ip { +res << vproto.pack_uint32_field(o.download_file_dfs_ip, 6) +} + +if o.has_download_file_dfs_port { +res << vproto.pack_uint32_field(o.download_file_dfs_port, 7) +} + +if o.has_download_file_url { +res << vproto.pack_string_field(o.download_file_url, 8) +} + +return res +} + +pub fn cmsgdrmfinalresult_unpack(buf []byte) ?CMsgDRmfinalResult { +mut res := CMsgDRmfinalResult{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +3 { +res.has_blob_download_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.blob_download_type = v +i = ii +} + +4 { +res.has_error_detail = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.error_detail = v +i = ii +} + +5 { +res.has_merge_guid = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.merge_guid = v +i = ii +} + +6 { +res.has_download_file_dfs_ip = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.download_file_dfs_ip = v +i = ii +} + +7 { +res.has_download_file_dfs_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.download_file_dfs_port = v +i = ii +} + +8 { +res.has_download_file_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.download_file_url = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgdrmfinalresult() CMsgDRmfinalResult { +return CMsgDRmfinalResult{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgdrmfinalresult(o CMsgDRmfinalResult, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgdrmfinalresult(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgDRmfinalResult) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgdrmfinalresult_unpack(v)? +return i, unpacked +} +pub struct CMsgClientDPcheckSpecialSurvey { +mut: +unknown_fields []vproto.UnknownField +pub mut: +survey_id u32 +has_survey_id bool +} +pub fn (o &CMsgClientDPcheckSpecialSurvey) pack() []byte { +mut res := []byte{} +if o.has_survey_id { +res << vproto.pack_uint32_field(o.survey_id, 1) +} + +return res +} + +pub fn cmsgclientdpcheckspecialsurvey_unpack(buf []byte) ?CMsgClientDPcheckSpecialSurvey { +mut res := CMsgClientDPcheckSpecialSurvey{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_survey_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.survey_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientdpcheckspecialsurvey() CMsgClientDPcheckSpecialSurvey { +return CMsgClientDPcheckSpecialSurvey{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientdpcheckspecialsurvey(o CMsgClientDPcheckSpecialSurvey, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientdpcheckspecialsurvey(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientDPcheckSpecialSurvey) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientdpcheckspecialsurvey_unpack(v)? +return i, unpacked +} +pub struct CMsgClientDPcheckSpecialSurveyResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult u32 +has_eresult bool +state u32 +has_state bool +name string +has_name bool +custom_url string +has_custom_url bool +include_software bool +has_include_software bool +token []byte +has_token bool +} +pub fn (o &CMsgClientDPcheckSpecialSurveyResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_uint32_field(o.eresult, 1) +} + +if o.has_state { +res << vproto.pack_uint32_field(o.state, 2) +} + +if o.has_name { +res << vproto.pack_string_field(o.name, 3) +} + +if o.has_custom_url { +res << vproto.pack_string_field(o.custom_url, 4) +} + +if o.has_include_software { +res << vproto.pack_bool_field(o.include_software, 5) +} + +if o.has_token { +res << vproto.pack_bytes_field(o.token, 6) +} + +return res +} + +pub fn cmsgclientdpcheckspecialsurveyresponse_unpack(buf []byte) ?CMsgClientDPcheckSpecialSurveyResponse { +mut res := CMsgClientDPcheckSpecialSurveyResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_state = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.state = v +i = ii +} + +3 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +4 { +res.has_custom_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.custom_url = v +i = ii +} + +5 { +res.has_include_software = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.include_software = v +i = ii +} + +6 { +res.has_token = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientdpcheckspecialsurveyresponse() CMsgClientDPcheckSpecialSurveyResponse { +return CMsgClientDPcheckSpecialSurveyResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientdpcheckspecialsurveyresponse(o CMsgClientDPcheckSpecialSurveyResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientdpcheckspecialsurveyresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientDPcheckSpecialSurveyResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientdpcheckspecialsurveyresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientDPsendSpecialSurveyResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +survey_id u32 +has_survey_id bool +data []byte +has_data bool +} +pub fn (o &CMsgClientDPsendSpecialSurveyResponse) pack() []byte { +mut res := []byte{} +if o.has_survey_id { +res << vproto.pack_uint32_field(o.survey_id, 1) +} + +if o.has_data { +res << vproto.pack_bytes_field(o.data, 2) +} + +return res +} + +pub fn cmsgclientdpsendspecialsurveyresponse_unpack(buf []byte) ?CMsgClientDPsendSpecialSurveyResponse { +mut res := CMsgClientDPsendSpecialSurveyResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_survey_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.survey_id = v +i = ii +} + +2 { +res.has_data = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.data = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientdpsendspecialsurveyresponse() CMsgClientDPsendSpecialSurveyResponse { +return CMsgClientDPsendSpecialSurveyResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientdpsendspecialsurveyresponse(o CMsgClientDPsendSpecialSurveyResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientdpsendspecialsurveyresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientDPsendSpecialSurveyResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientdpsendspecialsurveyresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientDPsendSpecialSurveyResponseReply { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult u32 +has_eresult bool +token []byte +has_token bool +} +pub fn (o &CMsgClientDPsendSpecialSurveyResponseReply) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_uint32_field(o.eresult, 1) +} + +if o.has_token { +res << vproto.pack_bytes_field(o.token, 2) +} + +return res +} + +pub fn cmsgclientdpsendspecialsurveyresponsereply_unpack(buf []byte) ?CMsgClientDPsendSpecialSurveyResponseReply { +mut res := CMsgClientDPsendSpecialSurveyResponseReply{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_token = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientdpsendspecialsurveyresponsereply() CMsgClientDPsendSpecialSurveyResponseReply { +return CMsgClientDPsendSpecialSurveyResponseReply{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientdpsendspecialsurveyresponsereply(o CMsgClientDPsendSpecialSurveyResponseReply, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientdpsendspecialsurveyresponsereply(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientDPsendSpecialSurveyResponseReply) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientdpsendspecialsurveyresponsereply_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRequestForgottenPasswordEmail { +mut: +unknown_fields []vproto.UnknownField +pub mut: +account_name string +has_account_name bool +password_tried string +has_password_tried bool +} +pub fn (o &CMsgClientRequestForgottenPasswordEmail) pack() []byte { +mut res := []byte{} +if o.has_account_name { +res << vproto.pack_string_field(o.account_name, 1) +} + +if o.has_password_tried { +res << vproto.pack_string_field(o.password_tried, 2) +} + +return res +} + +pub fn cmsgclientrequestforgottenpasswordemail_unpack(buf []byte) ?CMsgClientRequestForgottenPasswordEmail { +mut res := CMsgClientRequestForgottenPasswordEmail{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_account_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.account_name = v +i = ii +} + +2 { +res.has_password_tried = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.password_tried = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientrequestforgottenpasswordemail() CMsgClientRequestForgottenPasswordEmail { +return CMsgClientRequestForgottenPasswordEmail{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientrequestforgottenpasswordemail(o CMsgClientRequestForgottenPasswordEmail, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientrequestforgottenpasswordemail(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRequestForgottenPasswordEmail) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientrequestforgottenpasswordemail_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRequestForgottenPasswordEmailResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult u32 +has_eresult bool +use_secret_question bool +has_use_secret_question bool +} +pub fn (o &CMsgClientRequestForgottenPasswordEmailResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_uint32_field(o.eresult, 1) +} + +if o.has_use_secret_question { +res << vproto.pack_bool_field(o.use_secret_question, 2) +} + +return res +} + +pub fn cmsgclientrequestforgottenpasswordemailresponse_unpack(buf []byte) ?CMsgClientRequestForgottenPasswordEmailResponse { +mut res := CMsgClientRequestForgottenPasswordEmailResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_use_secret_question = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.use_secret_question = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientrequestforgottenpasswordemailresponse() CMsgClientRequestForgottenPasswordEmailResponse { +return CMsgClientRequestForgottenPasswordEmailResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientrequestforgottenpasswordemailresponse(o CMsgClientRequestForgottenPasswordEmailResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientrequestforgottenpasswordemailresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRequestForgottenPasswordEmailResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientrequestforgottenpasswordemailresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientItemAnnouncementsUnseenItem { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +context_id u64 +has_context_id bool +asset_id u64 +has_asset_id bool +amount u64 +has_amount bool +rtime32_gained u32 +has_rtime32_gained bool +source_appid u32 +has_source_appid bool +} +pub fn (o &CMsgClientItemAnnouncementsUnseenItem) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_context_id { +res << vproto.pack_uint64_field(o.context_id, 2) +} + +if o.has_asset_id { +res << vproto.pack_uint64_field(o.asset_id, 3) +} + +if o.has_amount { +res << vproto.pack_uint64_field(o.amount, 4) +} + +if o.has_rtime32_gained { +res << vproto.pack_32bit_field(o.rtime32_gained, 5) +} + +if o.has_source_appid { +res << vproto.pack_uint32_field(o.source_appid, 6) +} + +return res +} + +pub fn cmsgclientitemannouncementsunseenitem_unpack(buf []byte) ?CMsgClientItemAnnouncementsUnseenItem { +mut res := CMsgClientItemAnnouncementsUnseenItem{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_context_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.context_id = v +i = ii +} + +3 { +res.has_asset_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.asset_id = v +i = ii +} + +4 { +res.has_amount = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.amount = v +i = ii +} + +5 { +res.has_rtime32_gained = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.rtime32_gained = v +i = ii +} + +6 { +res.has_source_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.source_appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientitemannouncementsunseenitem() CMsgClientItemAnnouncementsUnseenItem { +return CMsgClientItemAnnouncementsUnseenItem{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientitemannouncementsunseenitem(o CMsgClientItemAnnouncementsUnseenItem, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientitemannouncementsunseenitem(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientItemAnnouncementsUnseenItem) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientitemannouncementsunseenitem_unpack(v)? +return i, unpacked +} +pub struct CMsgClientItemAnnouncements { +mut: +unknown_fields []vproto.UnknownField +pub mut: +count_new_items u32 +has_count_new_items bool +unseen_items []CMsgClientItemAnnouncementsUnseenItem +} +pub fn (o &CMsgClientItemAnnouncements) pack() []byte { +mut res := []byte{} +if o.has_count_new_items { +res << vproto.pack_uint32_field(o.count_new_items, 1) +} + +// [packed=false] +for _, x in o.unseen_items { +res << zzz_vproto_internal_pack_cmsgclientitemannouncementsunseenitem(x, 2) +} + +return res +} + +pub fn cmsgclientitemannouncements_unpack(buf []byte) ?CMsgClientItemAnnouncements { +mut res := CMsgClientItemAnnouncements{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_count_new_items = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.count_new_items = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientitemannouncementsunseenitem(cur_buf, tag_wiretype.wire_type)? +res.unseen_items << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientitemannouncements() CMsgClientItemAnnouncements { +return CMsgClientItemAnnouncements{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientitemannouncements(o CMsgClientItemAnnouncements, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientitemannouncements(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientItemAnnouncements) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientitemannouncements_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRequestItemAnnouncements { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CMsgClientRequestItemAnnouncements) pack() []byte { +res := []byte{} +return res +} + +pub fn cmsgclientrequestitemannouncements_unpack(buf []byte) ?CMsgClientRequestItemAnnouncements { +res := CMsgClientRequestItemAnnouncements{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientrequestitemannouncements() CMsgClientRequestItemAnnouncements { +return CMsgClientRequestItemAnnouncements{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientrequestitemannouncements(o CMsgClientRequestItemAnnouncements, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientrequestitemannouncements(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRequestItemAnnouncements) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientrequestitemannouncements_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUserNotificationsNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +user_notification_type u32 +has_user_notification_type bool +count u32 +has_count bool +} +pub fn (o &CMsgClientUserNotificationsNotification) pack() []byte { +mut res := []byte{} +if o.has_user_notification_type { +res << vproto.pack_uint32_field(o.user_notification_type, 1) +} + +if o.has_count { +res << vproto.pack_uint32_field(o.count, 2) +} + +return res +} + +pub fn cmsgclientusernotificationsnotification_unpack(buf []byte) ?CMsgClientUserNotificationsNotification { +mut res := CMsgClientUserNotificationsNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_user_notification_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.user_notification_type = v +i = ii +} + +2 { +res.has_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.count = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientusernotificationsnotification() CMsgClientUserNotificationsNotification { +return CMsgClientUserNotificationsNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientusernotificationsnotification(o CMsgClientUserNotificationsNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientusernotificationsnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUserNotificationsNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientusernotificationsnotification_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUserNotifications { +mut: +unknown_fields []vproto.UnknownField +pub mut: +notifications []CMsgClientUserNotificationsNotification +} +pub fn (o &CMsgClientUserNotifications) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.notifications { +res << zzz_vproto_internal_pack_cmsgclientusernotificationsnotification(x, 1) +} + +return res +} + +pub fn cmsgclientusernotifications_unpack(buf []byte) ?CMsgClientUserNotifications { +mut res := CMsgClientUserNotifications{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientusernotificationsnotification(cur_buf, tag_wiretype.wire_type)? +res.notifications << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientusernotifications() CMsgClientUserNotifications { +return CMsgClientUserNotifications{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientusernotifications(o CMsgClientUserNotifications, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientusernotifications(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUserNotifications) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientusernotifications_unpack(v)? +return i, unpacked +} +pub struct CMsgClientCommentNotifications { +mut: +unknown_fields []vproto.UnknownField +pub mut: +count_new_comments u32 +has_count_new_comments bool +count_new_comments_owner u32 +has_count_new_comments_owner bool +count_new_comments_subscriptions u32 +has_count_new_comments_subscriptions bool +} +pub fn (o &CMsgClientCommentNotifications) pack() []byte { +mut res := []byte{} +if o.has_count_new_comments { +res << vproto.pack_uint32_field(o.count_new_comments, 1) +} + +if o.has_count_new_comments_owner { +res << vproto.pack_uint32_field(o.count_new_comments_owner, 2) +} + +if o.has_count_new_comments_subscriptions { +res << vproto.pack_uint32_field(o.count_new_comments_subscriptions, 3) +} + +return res +} + +pub fn cmsgclientcommentnotifications_unpack(buf []byte) ?CMsgClientCommentNotifications { +mut res := CMsgClientCommentNotifications{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_count_new_comments = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.count_new_comments = v +i = ii +} + +2 { +res.has_count_new_comments_owner = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.count_new_comments_owner = v +i = ii +} + +3 { +res.has_count_new_comments_subscriptions = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.count_new_comments_subscriptions = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientcommentnotifications() CMsgClientCommentNotifications { +return CMsgClientCommentNotifications{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientcommentnotifications(o CMsgClientCommentNotifications, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientcommentnotifications(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientCommentNotifications) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientcommentnotifications_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRequestCommentNotifications { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CMsgClientRequestCommentNotifications) pack() []byte { +res := []byte{} +return res +} + +pub fn cmsgclientrequestcommentnotifications_unpack(buf []byte) ?CMsgClientRequestCommentNotifications { +res := CMsgClientRequestCommentNotifications{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientrequestcommentnotifications() CMsgClientRequestCommentNotifications { +return CMsgClientRequestCommentNotifications{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientrequestcommentnotifications(o CMsgClientRequestCommentNotifications, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientrequestcommentnotifications(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRequestCommentNotifications) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientrequestcommentnotifications_unpack(v)? +return i, unpacked +} +pub struct CMsgClientOfflineMessageNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +offline_messages u32 +has_offline_messages bool +friends_with_offline_messages []u32 +} +pub fn (o &CMsgClientOfflineMessageNotification) pack() []byte { +mut res := []byte{} +if o.has_offline_messages { +res << vproto.pack_uint32_field(o.offline_messages, 1) +} + +// [packed=false] +for _, x in o.friends_with_offline_messages { +res << vproto.pack_uint32_field(x, 2) +} + +return res +} + +pub fn cmsgclientofflinemessagenotification_unpack(buf []byte) ?CMsgClientOfflineMessageNotification { +mut res := CMsgClientOfflineMessageNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_offline_messages = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.offline_messages = v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.friends_with_offline_messages << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientofflinemessagenotification() CMsgClientOfflineMessageNotification { +return CMsgClientOfflineMessageNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientofflinemessagenotification(o CMsgClientOfflineMessageNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientofflinemessagenotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientOfflineMessageNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientofflinemessagenotification_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRequestOfflineMessageCount { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CMsgClientRequestOfflineMessageCount) pack() []byte { +res := []byte{} +return res +} + +pub fn cmsgclientrequestofflinemessagecount_unpack(buf []byte) ?CMsgClientRequestOfflineMessageCount { +res := CMsgClientRequestOfflineMessageCount{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientrequestofflinemessagecount() CMsgClientRequestOfflineMessageCount { +return CMsgClientRequestOfflineMessageCount{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientrequestofflinemessagecount(o CMsgClientRequestOfflineMessageCount, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientrequestofflinemessagecount(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRequestOfflineMessageCount) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientrequestofflinemessagecount_unpack(v)? +return i, unpacked +} +pub struct CMsgClientChatGetFriendMessageHistory { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +} +pub fn (o &CMsgClientChatGetFriendMessageHistory) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +return res +} + +pub fn cmsgclientchatgetfriendmessagehistory_unpack(buf []byte) ?CMsgClientChatGetFriendMessageHistory { +mut res := CMsgClientChatGetFriendMessageHistory{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientchatgetfriendmessagehistory() CMsgClientChatGetFriendMessageHistory { +return CMsgClientChatGetFriendMessageHistory{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientchatgetfriendmessagehistory(o CMsgClientChatGetFriendMessageHistory, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientchatgetfriendmessagehistory(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientChatGetFriendMessageHistory) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientchatgetfriendmessagehistory_unpack(v)? +return i, unpacked +} +pub struct CMsgClientChatGetFriendMessageHistoryResponseFriendMessage { +mut: +unknown_fields []vproto.UnknownField +pub mut: +accountid u32 +has_accountid bool +timestamp u32 +has_timestamp bool +message string +has_message bool +unread bool +has_unread bool +} +pub fn (o &CMsgClientChatGetFriendMessageHistoryResponseFriendMessage) pack() []byte { +mut res := []byte{} +if o.has_accountid { +res << vproto.pack_uint32_field(o.accountid, 1) +} + +if o.has_timestamp { +res << vproto.pack_uint32_field(o.timestamp, 2) +} + +if o.has_message { +res << vproto.pack_string_field(o.message, 3) +} + +if o.has_unread { +res << vproto.pack_bool_field(o.unread, 4) +} + +return res +} + +pub fn cmsgclientchatgetfriendmessagehistoryresponsefriendmessage_unpack(buf []byte) ?CMsgClientChatGetFriendMessageHistoryResponseFriendMessage { +mut res := CMsgClientChatGetFriendMessageHistoryResponseFriendMessage{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_accountid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.accountid = v +i = ii +} + +2 { +res.has_timestamp = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp = v +i = ii +} + +3 { +res.has_message = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.message = v +i = ii +} + +4 { +res.has_unread = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.unread = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientchatgetfriendmessagehistoryresponsefriendmessage() CMsgClientChatGetFriendMessageHistoryResponseFriendMessage { +return CMsgClientChatGetFriendMessageHistoryResponseFriendMessage{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientchatgetfriendmessagehistoryresponsefriendmessage(o CMsgClientChatGetFriendMessageHistoryResponseFriendMessage, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientchatgetfriendmessagehistoryresponsefriendmessage(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientChatGetFriendMessageHistoryResponseFriendMessage) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientchatgetfriendmessagehistoryresponsefriendmessage_unpack(v)? +return i, unpacked +} +pub struct CMsgClientChatGetFriendMessageHistoryResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +success u32 +has_success bool +messages []CMsgClientChatGetFriendMessageHistoryResponseFriendMessage +} +pub fn (o &CMsgClientChatGetFriendMessageHistoryResponse) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_success { +res << vproto.pack_uint32_field(o.success, 2) +} + +// [packed=false] +for _, x in o.messages { +res << zzz_vproto_internal_pack_cmsgclientchatgetfriendmessagehistoryresponsefriendmessage(x, 3) +} + +return res +} + +pub fn cmsgclientchatgetfriendmessagehistoryresponse_unpack(buf []byte) ?CMsgClientChatGetFriendMessageHistoryResponse { +mut res := CMsgClientChatGetFriendMessageHistoryResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_success = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.success = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientchatgetfriendmessagehistoryresponsefriendmessage(cur_buf, tag_wiretype.wire_type)? +res.messages << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientchatgetfriendmessagehistoryresponse() CMsgClientChatGetFriendMessageHistoryResponse { +return CMsgClientChatGetFriendMessageHistoryResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientchatgetfriendmessagehistoryresponse(o CMsgClientChatGetFriendMessageHistoryResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientchatgetfriendmessagehistoryresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientChatGetFriendMessageHistoryResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientchatgetfriendmessagehistoryresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientChatGetFriendMessageHistoryForOfflineMessages { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CMsgClientChatGetFriendMessageHistoryForOfflineMessages) pack() []byte { +res := []byte{} +return res +} + +pub fn cmsgclientchatgetfriendmessagehistoryforofflinemessages_unpack(buf []byte) ?CMsgClientChatGetFriendMessageHistoryForOfflineMessages { +res := CMsgClientChatGetFriendMessageHistoryForOfflineMessages{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientchatgetfriendmessagehistoryforofflinemessages() CMsgClientChatGetFriendMessageHistoryForOfflineMessages { +return CMsgClientChatGetFriendMessageHistoryForOfflineMessages{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientchatgetfriendmessagehistoryforofflinemessages(o CMsgClientChatGetFriendMessageHistoryForOfflineMessages, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientchatgetfriendmessagehistoryforofflinemessages(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientChatGetFriendMessageHistoryForOfflineMessages) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientchatgetfriendmessagehistoryforofflinemessages_unpack(v)? +return i, unpacked +} +pub struct CMsgClientFSgetFriendsSteamLevels { +mut: +unknown_fields []vproto.UnknownField +pub mut: +accountids []u32 +} +pub fn (o &CMsgClientFSgetFriendsSteamLevels) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.accountids { +res << vproto.pack_uint32_field(x, 1) +} + +return res +} + +pub fn cmsgclientfsgetfriendssteamlevels_unpack(buf []byte) ?CMsgClientFSgetFriendsSteamLevels { +mut res := CMsgClientFSgetFriendsSteamLevels{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.accountids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientfsgetfriendssteamlevels() CMsgClientFSgetFriendsSteamLevels { +return CMsgClientFSgetFriendsSteamLevels{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientfsgetfriendssteamlevels(o CMsgClientFSgetFriendsSteamLevels, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientfsgetfriendssteamlevels(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientFSgetFriendsSteamLevels) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientfsgetfriendssteamlevels_unpack(v)? +return i, unpacked +} +pub struct CMsgClientFSgetFriendsSteamLevelsResponseFriend { +mut: +unknown_fields []vproto.UnknownField +pub mut: +accountid u32 +has_accountid bool +level u32 +has_level bool +} +pub fn (o &CMsgClientFSgetFriendsSteamLevelsResponseFriend) pack() []byte { +mut res := []byte{} +if o.has_accountid { +res << vproto.pack_uint32_field(o.accountid, 1) +} + +if o.has_level { +res << vproto.pack_uint32_field(o.level, 2) +} + +return res +} + +pub fn cmsgclientfsgetfriendssteamlevelsresponsefriend_unpack(buf []byte) ?CMsgClientFSgetFriendsSteamLevelsResponseFriend { +mut res := CMsgClientFSgetFriendsSteamLevelsResponseFriend{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_accountid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.accountid = v +i = ii +} + +2 { +res.has_level = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.level = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientfsgetfriendssteamlevelsresponsefriend() CMsgClientFSgetFriendsSteamLevelsResponseFriend { +return CMsgClientFSgetFriendsSteamLevelsResponseFriend{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientfsgetfriendssteamlevelsresponsefriend(o CMsgClientFSgetFriendsSteamLevelsResponseFriend, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientfsgetfriendssteamlevelsresponsefriend(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientFSgetFriendsSteamLevelsResponseFriend) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientfsgetfriendssteamlevelsresponsefriend_unpack(v)? +return i, unpacked +} +pub struct CMsgClientFSgetFriendsSteamLevelsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +friends []CMsgClientFSgetFriendsSteamLevelsResponseFriend +} +pub fn (o &CMsgClientFSgetFriendsSteamLevelsResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.friends { +res << zzz_vproto_internal_pack_cmsgclientfsgetfriendssteamlevelsresponsefriend(x, 1) +} + +return res +} + +pub fn cmsgclientfsgetfriendssteamlevelsresponse_unpack(buf []byte) ?CMsgClientFSgetFriendsSteamLevelsResponse { +mut res := CMsgClientFSgetFriendsSteamLevelsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientfsgetfriendssteamlevelsresponsefriend(cur_buf, tag_wiretype.wire_type)? +res.friends << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientfsgetfriendssteamlevelsresponse() CMsgClientFSgetFriendsSteamLevelsResponse { +return CMsgClientFSgetFriendsSteamLevelsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientfsgetfriendssteamlevelsresponse(o CMsgClientFSgetFriendsSteamLevelsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientfsgetfriendssteamlevelsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientFSgetFriendsSteamLevelsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientfsgetfriendssteamlevelsresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientEmailAddrInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +email_address string +has_email_address bool +email_is_validated bool +has_email_is_validated bool +email_validation_changed bool +has_email_validation_changed bool +credential_change_requires_code bool +has_credential_change_requires_code bool +password_or_secretqa_change_requires_code bool +has_password_or_secretqa_change_requires_code bool +remind_user_about_email bool +has_remind_user_about_email bool +} +pub fn (o &CMsgClientEmailAddrInfo) pack() []byte { +mut res := []byte{} +if o.has_email_address { +res << vproto.pack_string_field(o.email_address, 1) +} + +if o.has_email_is_validated { +res << vproto.pack_bool_field(o.email_is_validated, 2) +} + +if o.has_email_validation_changed { +res << vproto.pack_bool_field(o.email_validation_changed, 3) +} + +if o.has_credential_change_requires_code { +res << vproto.pack_bool_field(o.credential_change_requires_code, 4) +} + +if o.has_password_or_secretqa_change_requires_code { +res << vproto.pack_bool_field(o.password_or_secretqa_change_requires_code, 5) +} + +if o.has_remind_user_about_email { +res << vproto.pack_bool_field(o.remind_user_about_email, 6) +} + +return res +} + +pub fn cmsgclientemailaddrinfo_unpack(buf []byte) ?CMsgClientEmailAddrInfo { +mut res := CMsgClientEmailAddrInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_email_address = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.email_address = v +i = ii +} + +2 { +res.has_email_is_validated = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.email_is_validated = v +i = ii +} + +3 { +res.has_email_validation_changed = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.email_validation_changed = v +i = ii +} + +4 { +res.has_credential_change_requires_code = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.credential_change_requires_code = v +i = ii +} + +5 { +res.has_password_or_secretqa_change_requires_code = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.password_or_secretqa_change_requires_code = v +i = ii +} + +6 { +res.has_remind_user_about_email = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.remind_user_about_email = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientemailaddrinfo() CMsgClientEmailAddrInfo { +return CMsgClientEmailAddrInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientemailaddrinfo(o CMsgClientEmailAddrInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientemailaddrinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientEmailAddrInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientemailaddrinfo_unpack(v)? +return i, unpacked +} +pub struct CMsgCReitemVoteSummaryPublishedFileId { +mut: +unknown_fields []vproto.UnknownField +pub mut: +published_file_id u64 +has_published_file_id bool +} +pub fn (o &CMsgCReitemVoteSummaryPublishedFileId) pack() []byte { +mut res := []byte{} +if o.has_published_file_id { +res << vproto.pack_64bit_field(o.published_file_id, 1) +} + +return res +} + +pub fn cmsgcreitemvotesummarypublishedfileid_unpack(buf []byte) ?CMsgCReitemVoteSummaryPublishedFileId { +mut res := CMsgCReitemVoteSummaryPublishedFileId{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_published_file_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.published_file_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgcreitemvotesummarypublishedfileid() CMsgCReitemVoteSummaryPublishedFileId { +return CMsgCReitemVoteSummaryPublishedFileId{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgcreitemvotesummarypublishedfileid(o CMsgCReitemVoteSummaryPublishedFileId, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgcreitemvotesummarypublishedfileid(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgCReitemVoteSummaryPublishedFileId) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgcreitemvotesummarypublishedfileid_unpack(v)? +return i, unpacked +} +pub struct CMsgCReitemVoteSummary { +mut: +unknown_fields []vproto.UnknownField +pub mut: +published_file_ids []CMsgCReitemVoteSummaryPublishedFileId +} +pub fn (o &CMsgCReitemVoteSummary) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.published_file_ids { +res << zzz_vproto_internal_pack_cmsgcreitemvotesummarypublishedfileid(x, 1) +} + +return res +} + +pub fn cmsgcreitemvotesummary_unpack(buf []byte) ?CMsgCReitemVoteSummary { +mut res := CMsgCReitemVoteSummary{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgcreitemvotesummarypublishedfileid(cur_buf, tag_wiretype.wire_type)? +res.published_file_ids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgcreitemvotesummary() CMsgCReitemVoteSummary { +return CMsgCReitemVoteSummary{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgcreitemvotesummary(o CMsgCReitemVoteSummary, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgcreitemvotesummary(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgCReitemVoteSummary) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgcreitemvotesummary_unpack(v)? +return i, unpacked +} +pub struct CMsgCReitemVoteSummaryResponseItemVoteSummary { +mut: +unknown_fields []vproto.UnknownField +pub mut: +published_file_id u64 +has_published_file_id bool +votes_for int +has_votes_for bool +votes_against int +has_votes_against bool +reports int +has_reports bool +score f32 +has_score bool +} +pub fn (o &CMsgCReitemVoteSummaryResponseItemVoteSummary) pack() []byte { +mut res := []byte{} +if o.has_published_file_id { +res << vproto.pack_64bit_field(o.published_file_id, 1) +} + +if o.has_votes_for { +res << vproto.pack_int32_field(o.votes_for, 2) +} + +if o.has_votes_against { +res << vproto.pack_int32_field(o.votes_against, 3) +} + +if o.has_reports { +res << vproto.pack_int32_field(o.reports, 4) +} + +if o.has_score { +res << vproto.pack_float_field(o.score, 5) +} + +return res +} + +pub fn cmsgcreitemvotesummaryresponseitemvotesummary_unpack(buf []byte) ?CMsgCReitemVoteSummaryResponseItemVoteSummary { +mut res := CMsgCReitemVoteSummaryResponseItemVoteSummary{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_published_file_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.published_file_id = v +i = ii +} + +2 { +res.has_votes_for = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.votes_for = v +i = ii +} + +3 { +res.has_votes_against = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.votes_against = v +i = ii +} + +4 { +res.has_reports = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.reports = v +i = ii +} + +5 { +res.has_score = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.score = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgcreitemvotesummaryresponseitemvotesummary() CMsgCReitemVoteSummaryResponseItemVoteSummary { +return CMsgCReitemVoteSummaryResponseItemVoteSummary{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgcreitemvotesummaryresponseitemvotesummary(o CMsgCReitemVoteSummaryResponseItemVoteSummary, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgcreitemvotesummaryresponseitemvotesummary(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgCReitemVoteSummaryResponseItemVoteSummary) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgcreitemvotesummaryresponseitemvotesummary_unpack(v)? +return i, unpacked +} +pub struct CMsgCReitemVoteSummaryResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +item_vote_summaries []CMsgCReitemVoteSummaryResponseItemVoteSummary +} +pub fn (o &CMsgCReitemVoteSummaryResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +// [packed=false] +for _, x in o.item_vote_summaries { +res << zzz_vproto_internal_pack_cmsgcreitemvotesummaryresponseitemvotesummary(x, 2) +} + +return res +} + +pub fn cmsgcreitemvotesummaryresponse_unpack(buf []byte) ?CMsgCReitemVoteSummaryResponse { +mut res := CMsgCReitemVoteSummaryResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgcreitemvotesummaryresponseitemvotesummary(cur_buf, tag_wiretype.wire_type)? +res.item_vote_summaries << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgcreitemvotesummaryresponse() CMsgCReitemVoteSummaryResponse { +return CMsgCReitemVoteSummaryResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgcreitemvotesummaryresponse(o CMsgCReitemVoteSummaryResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgcreitemvotesummaryresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgCReitemVoteSummaryResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgcreitemvotesummaryresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgCReupdateUserPublishedItemVote { +mut: +unknown_fields []vproto.UnknownField +pub mut: +published_file_id u64 +has_published_file_id bool +vote_up bool +has_vote_up bool +} +pub fn (o &CMsgCReupdateUserPublishedItemVote) pack() []byte { +mut res := []byte{} +if o.has_published_file_id { +res << vproto.pack_64bit_field(o.published_file_id, 1) +} + +if o.has_vote_up { +res << vproto.pack_bool_field(o.vote_up, 2) +} + +return res +} + +pub fn cmsgcreupdateuserpublisheditemvote_unpack(buf []byte) ?CMsgCReupdateUserPublishedItemVote { +mut res := CMsgCReupdateUserPublishedItemVote{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_published_file_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.published_file_id = v +i = ii +} + +2 { +res.has_vote_up = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.vote_up = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgcreupdateuserpublisheditemvote() CMsgCReupdateUserPublishedItemVote { +return CMsgCReupdateUserPublishedItemVote{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgcreupdateuserpublisheditemvote(o CMsgCReupdateUserPublishedItemVote, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgcreupdateuserpublisheditemvote(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgCReupdateUserPublishedItemVote) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgcreupdateuserpublisheditemvote_unpack(v)? +return i, unpacked +} +pub struct CMsgCReupdateUserPublishedItemVoteResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +} +pub fn (o &CMsgCReupdateUserPublishedItemVoteResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +return res +} + +pub fn cmsgcreupdateuserpublisheditemvoteresponse_unpack(buf []byte) ?CMsgCReupdateUserPublishedItemVoteResponse { +mut res := CMsgCReupdateUserPublishedItemVoteResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgcreupdateuserpublisheditemvoteresponse() CMsgCReupdateUserPublishedItemVoteResponse { +return CMsgCReupdateUserPublishedItemVoteResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgcreupdateuserpublisheditemvoteresponse(o CMsgCReupdateUserPublishedItemVoteResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgcreupdateuserpublisheditemvoteresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgCReupdateUserPublishedItemVoteResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgcreupdateuserpublisheditemvoteresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgCRegetUserPublishedItemVoteDetailsPublishedFileId { +mut: +unknown_fields []vproto.UnknownField +pub mut: +published_file_id u64 +has_published_file_id bool +} +pub fn (o &CMsgCRegetUserPublishedItemVoteDetailsPublishedFileId) pack() []byte { +mut res := []byte{} +if o.has_published_file_id { +res << vproto.pack_64bit_field(o.published_file_id, 1) +} + +return res +} + +pub fn cmsgcregetuserpublisheditemvotedetailspublishedfileid_unpack(buf []byte) ?CMsgCRegetUserPublishedItemVoteDetailsPublishedFileId { +mut res := CMsgCRegetUserPublishedItemVoteDetailsPublishedFileId{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_published_file_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.published_file_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgcregetuserpublisheditemvotedetailspublishedfileid() CMsgCRegetUserPublishedItemVoteDetailsPublishedFileId { +return CMsgCRegetUserPublishedItemVoteDetailsPublishedFileId{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgcregetuserpublisheditemvotedetailspublishedfileid(o CMsgCRegetUserPublishedItemVoteDetailsPublishedFileId, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgcregetuserpublisheditemvotedetailspublishedfileid(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgCRegetUserPublishedItemVoteDetailsPublishedFileId) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgcregetuserpublisheditemvotedetailspublishedfileid_unpack(v)? +return i, unpacked +} +pub struct CMsgCRegetUserPublishedItemVoteDetails { +mut: +unknown_fields []vproto.UnknownField +pub mut: +published_file_ids []CMsgCRegetUserPublishedItemVoteDetailsPublishedFileId +} +pub fn (o &CMsgCRegetUserPublishedItemVoteDetails) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.published_file_ids { +res << zzz_vproto_internal_pack_cmsgcregetuserpublisheditemvotedetailspublishedfileid(x, 1) +} + +return res +} + +pub fn cmsgcregetuserpublisheditemvotedetails_unpack(buf []byte) ?CMsgCRegetUserPublishedItemVoteDetails { +mut res := CMsgCRegetUserPublishedItemVoteDetails{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgcregetuserpublisheditemvotedetailspublishedfileid(cur_buf, tag_wiretype.wire_type)? +res.published_file_ids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgcregetuserpublisheditemvotedetails() CMsgCRegetUserPublishedItemVoteDetails { +return CMsgCRegetUserPublishedItemVoteDetails{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgcregetuserpublisheditemvotedetails(o CMsgCRegetUserPublishedItemVoteDetails, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgcregetuserpublisheditemvotedetails(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgCRegetUserPublishedItemVoteDetails) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgcregetuserpublisheditemvotedetails_unpack(v)? +return i, unpacked +} +pub struct CMsgCRegetUserPublishedItemVoteDetailsResponseUserItemVoteDetail { +mut: +unknown_fields []vproto.UnknownField +pub mut: +published_file_id u64 +has_published_file_id bool +vote int +has_vote bool +} +pub fn (o &CMsgCRegetUserPublishedItemVoteDetailsResponseUserItemVoteDetail) pack() []byte { +mut res := []byte{} +if o.has_published_file_id { +res << vproto.pack_64bit_field(o.published_file_id, 1) +} + +if o.has_vote { +res << vproto.pack_int32_field(o.vote, 2) +} + +return res +} + +pub fn cmsgcregetuserpublisheditemvotedetailsresponseuseritemvotedetail_unpack(buf []byte) ?CMsgCRegetUserPublishedItemVoteDetailsResponseUserItemVoteDetail { +mut res := CMsgCRegetUserPublishedItemVoteDetailsResponseUserItemVoteDetail{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_published_file_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.published_file_id = v +i = ii +} + +2 { +res.has_vote = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.vote = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgcregetuserpublisheditemvotedetailsresponseuseritemvotedetail() CMsgCRegetUserPublishedItemVoteDetailsResponseUserItemVoteDetail { +return CMsgCRegetUserPublishedItemVoteDetailsResponseUserItemVoteDetail{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgcregetuserpublisheditemvotedetailsresponseuseritemvotedetail(o CMsgCRegetUserPublishedItemVoteDetailsResponseUserItemVoteDetail, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgcregetuserpublisheditemvotedetailsresponseuseritemvotedetail(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgCRegetUserPublishedItemVoteDetailsResponseUserItemVoteDetail) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgcregetuserpublisheditemvotedetailsresponseuseritemvotedetail_unpack(v)? +return i, unpacked +} +pub struct CMsgCRegetUserPublishedItemVoteDetailsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +user_item_vote_details []CMsgCRegetUserPublishedItemVoteDetailsResponseUserItemVoteDetail +} +pub fn (o &CMsgCRegetUserPublishedItemVoteDetailsResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +// [packed=false] +for _, x in o.user_item_vote_details { +res << zzz_vproto_internal_pack_cmsgcregetuserpublisheditemvotedetailsresponseuseritemvotedetail(x, 2) +} + +return res +} + +pub fn cmsgcregetuserpublisheditemvotedetailsresponse_unpack(buf []byte) ?CMsgCRegetUserPublishedItemVoteDetailsResponse { +mut res := CMsgCRegetUserPublishedItemVoteDetailsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgcregetuserpublisheditemvotedetailsresponseuseritemvotedetail(cur_buf, tag_wiretype.wire_type)? +res.user_item_vote_details << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgcregetuserpublisheditemvotedetailsresponse() CMsgCRegetUserPublishedItemVoteDetailsResponse { +return CMsgCRegetUserPublishedItemVoteDetailsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgcregetuserpublisheditemvotedetailsresponse(o CMsgCRegetUserPublishedItemVoteDetailsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgcregetuserpublisheditemvotedetailsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgCRegetUserPublishedItemVoteDetailsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgcregetuserpublisheditemvotedetailsresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgGameServerPingSampleSample { +mut: +unknown_fields []vproto.UnknownField +pub mut: +ip u32 +has_ip bool +avg_ping_ms u32 +has_avg_ping_ms bool +stddev_ping_ms_x10 u32 +has_stddev_ping_ms_x10 bool +} +pub fn (o &CMsgGameServerPingSampleSample) pack() []byte { +mut res := []byte{} +if o.has_ip { +res << vproto.pack_32bit_field(o.ip, 1) +} + +if o.has_avg_ping_ms { +res << vproto.pack_uint32_field(o.avg_ping_ms, 2) +} + +if o.has_stddev_ping_ms_x10 { +res << vproto.pack_uint32_field(o.stddev_ping_ms_x10, 3) +} + +return res +} + +pub fn cmsggameserverpingsamplesample_unpack(buf []byte) ?CMsgGameServerPingSampleSample { +mut res := CMsgGameServerPingSampleSample{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_ip = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.ip = v +i = ii +} + +2 { +res.has_avg_ping_ms = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.avg_ping_ms = v +i = ii +} + +3 { +res.has_stddev_ping_ms_x10 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.stddev_ping_ms_x10 = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggameserverpingsamplesample() CMsgGameServerPingSampleSample { +return CMsgGameServerPingSampleSample{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggameserverpingsamplesample(o CMsgGameServerPingSampleSample, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggameserverpingsamplesample(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGameServerPingSampleSample) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggameserverpingsamplesample_unpack(v)? +return i, unpacked +} +pub struct CMsgGameServerPingSample { +mut: +unknown_fields []vproto.UnknownField +pub mut: +my_ip u32 +has_my_ip bool +gs_app_id int +has_gs_app_id bool +gs_samples []CMsgGameServerPingSampleSample +} +pub fn (o &CMsgGameServerPingSample) pack() []byte { +mut res := []byte{} +if o.has_my_ip { +res << vproto.pack_32bit_field(o.my_ip, 1) +} + +if o.has_gs_app_id { +res << vproto.pack_int32_field(o.gs_app_id, 2) +} + +// [packed=false] +for _, x in o.gs_samples { +res << zzz_vproto_internal_pack_cmsggameserverpingsamplesample(x, 3) +} + +return res +} + +pub fn cmsggameserverpingsample_unpack(buf []byte) ?CMsgGameServerPingSample { +mut res := CMsgGameServerPingSample{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_my_ip = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.my_ip = v +i = ii +} + +2 { +res.has_gs_app_id = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.gs_app_id = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsggameserverpingsamplesample(cur_buf, tag_wiretype.wire_type)? +res.gs_samples << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggameserverpingsample() CMsgGameServerPingSample { +return CMsgGameServerPingSample{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggameserverpingsample(o CMsgGameServerPingSample, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggameserverpingsample(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGameServerPingSample) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggameserverpingsample_unpack(v)? +return i, unpacked +} +pub struct CMsgFSgetFollowerCount { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id u64 +has_steam_id bool +} +pub fn (o &CMsgFSgetFollowerCount) pack() []byte { +mut res := []byte{} +if o.has_steam_id { +res << vproto.pack_64bit_field(o.steam_id, 1) +} + +return res +} + +pub fn cmsgfsgetfollowercount_unpack(buf []byte) ?CMsgFSgetFollowerCount { +mut res := CMsgFSgetFollowerCount{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgfsgetfollowercount() CMsgFSgetFollowerCount { +return CMsgFSgetFollowerCount{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgfsgetfollowercount(o CMsgFSgetFollowerCount, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgfsgetfollowercount(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgFSgetFollowerCount) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgfsgetfollowercount_unpack(v)? +return i, unpacked +} +pub struct CMsgFSgetFollowerCountResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +count int +has_count bool +} +pub fn (o &CMsgFSgetFollowerCountResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_count { +res << vproto.pack_int32_field(o.count, 2) +} + +return res +} + +pub fn cmsgfsgetfollowercountresponse_unpack(buf []byte) ?CMsgFSgetFollowerCountResponse { +mut res := CMsgFSgetFollowerCountResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.count = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgfsgetfollowercountresponse() CMsgFSgetFollowerCountResponse { +return CMsgFSgetFollowerCountResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgfsgetfollowercountresponse(o CMsgFSgetFollowerCountResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgfsgetfollowercountresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgFSgetFollowerCountResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgfsgetfollowercountresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgFSgetIsFollowing { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id u64 +has_steam_id bool +} +pub fn (o &CMsgFSgetIsFollowing) pack() []byte { +mut res := []byte{} +if o.has_steam_id { +res << vproto.pack_64bit_field(o.steam_id, 1) +} + +return res +} + +pub fn cmsgfsgetisfollowing_unpack(buf []byte) ?CMsgFSgetIsFollowing { +mut res := CMsgFSgetIsFollowing{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgfsgetisfollowing() CMsgFSgetIsFollowing { +return CMsgFSgetIsFollowing{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgfsgetisfollowing(o CMsgFSgetIsFollowing, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgfsgetisfollowing(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgFSgetIsFollowing) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgfsgetisfollowing_unpack(v)? +return i, unpacked +} +pub struct CMsgFSgetIsFollowingResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +is_following bool +has_is_following bool +} +pub fn (o &CMsgFSgetIsFollowingResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_is_following { +res << vproto.pack_bool_field(o.is_following, 2) +} + +return res +} + +pub fn cmsgfsgetisfollowingresponse_unpack(buf []byte) ?CMsgFSgetIsFollowingResponse { +mut res := CMsgFSgetIsFollowingResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_is_following = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_following = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgfsgetisfollowingresponse() CMsgFSgetIsFollowingResponse { +return CMsgFSgetIsFollowingResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgfsgetisfollowingresponse(o CMsgFSgetIsFollowingResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgfsgetisfollowingresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgFSgetIsFollowingResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgfsgetisfollowingresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgFSenumerateFollowingList { +mut: +unknown_fields []vproto.UnknownField +pub mut: +start_index u32 +has_start_index bool +} +pub fn (o &CMsgFSenumerateFollowingList) pack() []byte { +mut res := []byte{} +if o.has_start_index { +res << vproto.pack_uint32_field(o.start_index, 1) +} + +return res +} + +pub fn cmsgfsenumeratefollowinglist_unpack(buf []byte) ?CMsgFSenumerateFollowingList { +mut res := CMsgFSenumerateFollowingList{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_start_index = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.start_index = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgfsenumeratefollowinglist() CMsgFSenumerateFollowingList { +return CMsgFSenumerateFollowingList{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgfsenumeratefollowinglist(o CMsgFSenumerateFollowingList, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgfsenumeratefollowinglist(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgFSenumerateFollowingList) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgfsenumeratefollowinglist_unpack(v)? +return i, unpacked +} +pub struct CMsgFSenumerateFollowingListResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +total_results int +has_total_results bool +steam_ids []u64 +} +pub fn (o &CMsgFSenumerateFollowingListResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_total_results { +res << vproto.pack_int32_field(o.total_results, 2) +} + +// [packed=false] +for _, x in o.steam_ids { +res << vproto.pack_64bit_field(x, 3) +} + +return res +} + +pub fn cmsgfsenumeratefollowinglistresponse_unpack(buf []byte) ?CMsgFSenumerateFollowingListResponse { +mut res := CMsgFSenumerateFollowingListResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_total_results = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.total_results = v +i = ii +} + +3 { +// [packed=false] +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_ids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgfsenumeratefollowinglistresponse() CMsgFSenumerateFollowingListResponse { +return CMsgFSenumerateFollowingListResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgfsenumeratefollowinglistresponse(o CMsgFSenumerateFollowingListResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgfsenumeratefollowinglistresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgFSenumerateFollowingListResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgfsenumeratefollowinglistresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgDPgetNumberOfCurrentPlayers { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +} +pub fn (o &CMsgDPgetNumberOfCurrentPlayers) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +return res +} + +pub fn cmsgdpgetnumberofcurrentplayers_unpack(buf []byte) ?CMsgDPgetNumberOfCurrentPlayers { +mut res := CMsgDPgetNumberOfCurrentPlayers{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgdpgetnumberofcurrentplayers() CMsgDPgetNumberOfCurrentPlayers { +return CMsgDPgetNumberOfCurrentPlayers{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgdpgetnumberofcurrentplayers(o CMsgDPgetNumberOfCurrentPlayers, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgdpgetnumberofcurrentplayers(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgDPgetNumberOfCurrentPlayers) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgdpgetnumberofcurrentplayers_unpack(v)? +return i, unpacked +} +pub struct CMsgDPgetNumberOfCurrentPlayersResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +player_count int +has_player_count bool +} +pub fn (o &CMsgDPgetNumberOfCurrentPlayersResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_player_count { +res << vproto.pack_int32_field(o.player_count, 2) +} + +return res +} + +pub fn cmsgdpgetnumberofcurrentplayersresponse_unpack(buf []byte) ?CMsgDPgetNumberOfCurrentPlayersResponse { +mut res := CMsgDPgetNumberOfCurrentPlayersResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_player_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.player_count = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgdpgetnumberofcurrentplayersresponse() CMsgDPgetNumberOfCurrentPlayersResponse { +return CMsgDPgetNumberOfCurrentPlayersResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgdpgetnumberofcurrentplayersresponse(o CMsgDPgetNumberOfCurrentPlayersResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgdpgetnumberofcurrentplayersresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgDPgetNumberOfCurrentPlayersResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgdpgetnumberofcurrentplayersresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientFriendUserStatusPublished { +mut: +unknown_fields []vproto.UnknownField +pub mut: +friend_steamid u64 +has_friend_steamid bool +appid u32 +has_appid bool +status_text string +has_status_text bool +} +pub fn (o &CMsgClientFriendUserStatusPublished) pack() []byte { +mut res := []byte{} +if o.has_friend_steamid { +res << vproto.pack_64bit_field(o.friend_steamid, 1) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 2) +} + +if o.has_status_text { +res << vproto.pack_string_field(o.status_text, 3) +} + +return res +} + +pub fn cmsgclientfrienduserstatuspublished_unpack(buf []byte) ?CMsgClientFriendUserStatusPublished { +mut res := CMsgClientFriendUserStatusPublished{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_friend_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.friend_steamid = v +i = ii +} + +2 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +3 { +res.has_status_text = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.status_text = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientfrienduserstatuspublished() CMsgClientFriendUserStatusPublished { +return CMsgClientFriendUserStatusPublished{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientfrienduserstatuspublished(o CMsgClientFriendUserStatusPublished, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientfrienduserstatuspublished(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientFriendUserStatusPublished) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientfrienduserstatuspublished_unpack(v)? +return i, unpacked +} +pub struct CMsgClientServiceMethodLegacy { +mut: +unknown_fields []vproto.UnknownField +pub mut: +method_name string +has_method_name bool +serialized_method []byte +has_serialized_method bool +is_notification bool +has_is_notification bool +} +pub fn (o &CMsgClientServiceMethodLegacy) pack() []byte { +mut res := []byte{} +if o.has_method_name { +res << vproto.pack_string_field(o.method_name, 1) +} + +if o.has_serialized_method { +res << vproto.pack_bytes_field(o.serialized_method, 2) +} + +if o.has_is_notification { +res << vproto.pack_bool_field(o.is_notification, 3) +} + +return res +} + +pub fn cmsgclientservicemethodlegacy_unpack(buf []byte) ?CMsgClientServiceMethodLegacy { +mut res := CMsgClientServiceMethodLegacy{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_method_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.method_name = v +i = ii +} + +2 { +res.has_serialized_method = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.serialized_method = v +i = ii +} + +3 { +res.has_is_notification = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_notification = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientservicemethodlegacy() CMsgClientServiceMethodLegacy { +return CMsgClientServiceMethodLegacy{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientservicemethodlegacy(o CMsgClientServiceMethodLegacy, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientservicemethodlegacy(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientServiceMethodLegacy) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientservicemethodlegacy_unpack(v)? +return i, unpacked +} +pub struct CMsgClientServiceMethodLegacyResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +method_name string +has_method_name bool +serialized_method_response []byte +has_serialized_method_response bool +} +pub fn (o &CMsgClientServiceMethodLegacyResponse) pack() []byte { +mut res := []byte{} +if o.has_method_name { +res << vproto.pack_string_field(o.method_name, 1) +} + +if o.has_serialized_method_response { +res << vproto.pack_bytes_field(o.serialized_method_response, 2) +} + +return res +} + +pub fn cmsgclientservicemethodlegacyresponse_unpack(buf []byte) ?CMsgClientServiceMethodLegacyResponse { +mut res := CMsgClientServiceMethodLegacyResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_method_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.method_name = v +i = ii +} + +2 { +res.has_serialized_method_response = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.serialized_method_response = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientservicemethodlegacyresponse() CMsgClientServiceMethodLegacyResponse { +return CMsgClientServiceMethodLegacyResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientservicemethodlegacyresponse(o CMsgClientServiceMethodLegacyResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientservicemethodlegacyresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientServiceMethodLegacyResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientservicemethodlegacyresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUImode { +mut: +unknown_fields []vproto.UnknownField +pub mut: +uimode u32 +has_uimode bool +chat_mode u32 +has_chat_mode bool +} +pub fn (o &CMsgClientUImode) pack() []byte { +mut res := []byte{} +if o.has_uimode { +res << vproto.pack_uint32_field(o.uimode, 1) +} + +if o.has_chat_mode { +res << vproto.pack_uint32_field(o.chat_mode, 2) +} + +return res +} + +pub fn cmsgclientuimode_unpack(buf []byte) ?CMsgClientUImode { +mut res := CMsgClientUImode{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_uimode = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.uimode = v +i = ii +} + +2 { +res.has_chat_mode = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.chat_mode = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientuimode() CMsgClientUImode { +return CMsgClientUImode{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientuimode(o CMsgClientUImode, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientuimode(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUImode) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientuimode_unpack(v)? +return i, unpacked +} +pub struct CMsgClientVanityURlchangedNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +vanity_url string +has_vanity_url bool +} +pub fn (o &CMsgClientVanityURlchangedNotification) pack() []byte { +mut res := []byte{} +if o.has_vanity_url { +res << vproto.pack_string_field(o.vanity_url, 1) +} + +return res +} + +pub fn cmsgclientvanityurlchangednotification_unpack(buf []byte) ?CMsgClientVanityURlchangedNotification { +mut res := CMsgClientVanityURlchangedNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_vanity_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.vanity_url = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientvanityurlchangednotification() CMsgClientVanityURlchangedNotification { +return CMsgClientVanityURlchangedNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientvanityurlchangednotification(o CMsgClientVanityURlchangedNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientvanityurlchangednotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientVanityURlchangedNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientvanityurlchangednotification_unpack(v)? +return i, unpacked +} +pub struct CMsgClientAuthorizeLocalDeviceRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +device_description string +has_device_description bool +owner_account_id u32 +has_owner_account_id bool +local_device_token u64 +has_local_device_token bool +} +pub fn (o &CMsgClientAuthorizeLocalDeviceRequest) pack() []byte { +mut res := []byte{} +if o.has_device_description { +res << vproto.pack_string_field(o.device_description, 1) +} + +if o.has_owner_account_id { +res << vproto.pack_uint32_field(o.owner_account_id, 2) +} + +if o.has_local_device_token { +res << vproto.pack_uint64_field(o.local_device_token, 3) +} + +return res +} + +pub fn cmsgclientauthorizelocaldevicerequest_unpack(buf []byte) ?CMsgClientAuthorizeLocalDeviceRequest { +mut res := CMsgClientAuthorizeLocalDeviceRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_device_description = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.device_description = v +i = ii +} + +2 { +res.has_owner_account_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.owner_account_id = v +i = ii +} + +3 { +res.has_local_device_token = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.local_device_token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientauthorizelocaldevicerequest() CMsgClientAuthorizeLocalDeviceRequest { +return CMsgClientAuthorizeLocalDeviceRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientauthorizelocaldevicerequest(o CMsgClientAuthorizeLocalDeviceRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientauthorizelocaldevicerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientAuthorizeLocalDeviceRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientauthorizelocaldevicerequest_unpack(v)? +return i, unpacked +} +pub struct CMsgClientAuthorizeLocalDevice { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +owner_account_id u32 +has_owner_account_id bool +authed_device_token u64 +has_authed_device_token bool +} +pub fn (o &CMsgClientAuthorizeLocalDevice) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_owner_account_id { +res << vproto.pack_uint32_field(o.owner_account_id, 2) +} + +if o.has_authed_device_token { +res << vproto.pack_uint64_field(o.authed_device_token, 3) +} + +return res +} + +pub fn cmsgclientauthorizelocaldevice_unpack(buf []byte) ?CMsgClientAuthorizeLocalDevice { +mut res := CMsgClientAuthorizeLocalDevice{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_owner_account_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.owner_account_id = v +i = ii +} + +3 { +res.has_authed_device_token = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.authed_device_token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientauthorizelocaldevice() CMsgClientAuthorizeLocalDevice { +return CMsgClientAuthorizeLocalDevice{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientauthorizelocaldevice(o CMsgClientAuthorizeLocalDevice, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientauthorizelocaldevice(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientAuthorizeLocalDevice) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientauthorizelocaldevice_unpack(v)? +return i, unpacked +} +pub struct CMsgClientAuthorizeLocalDeviceNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +owner_account_id u32 +has_owner_account_id bool +local_device_token u64 +has_local_device_token bool +} +pub fn (o &CMsgClientAuthorizeLocalDeviceNotification) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_owner_account_id { +res << vproto.pack_uint32_field(o.owner_account_id, 2) +} + +if o.has_local_device_token { +res << vproto.pack_uint64_field(o.local_device_token, 3) +} + +return res +} + +pub fn cmsgclientauthorizelocaldevicenotification_unpack(buf []byte) ?CMsgClientAuthorizeLocalDeviceNotification { +mut res := CMsgClientAuthorizeLocalDeviceNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_owner_account_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.owner_account_id = v +i = ii +} + +3 { +res.has_local_device_token = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.local_device_token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientauthorizelocaldevicenotification() CMsgClientAuthorizeLocalDeviceNotification { +return CMsgClientAuthorizeLocalDeviceNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientauthorizelocaldevicenotification(o CMsgClientAuthorizeLocalDeviceNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientauthorizelocaldevicenotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientAuthorizeLocalDeviceNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientauthorizelocaldevicenotification_unpack(v)? +return i, unpacked +} +pub struct CMsgClientDeauthorizeDeviceRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +deauthorization_account_id u32 +has_deauthorization_account_id bool +deauthorization_device_token u64 +has_deauthorization_device_token bool +} +pub fn (o &CMsgClientDeauthorizeDeviceRequest) pack() []byte { +mut res := []byte{} +if o.has_deauthorization_account_id { +res << vproto.pack_uint32_field(o.deauthorization_account_id, 1) +} + +if o.has_deauthorization_device_token { +res << vproto.pack_uint64_field(o.deauthorization_device_token, 2) +} + +return res +} + +pub fn cmsgclientdeauthorizedevicerequest_unpack(buf []byte) ?CMsgClientDeauthorizeDeviceRequest { +mut res := CMsgClientDeauthorizeDeviceRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_deauthorization_account_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.deauthorization_account_id = v +i = ii +} + +2 { +res.has_deauthorization_device_token = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.deauthorization_device_token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientdeauthorizedevicerequest() CMsgClientDeauthorizeDeviceRequest { +return CMsgClientDeauthorizeDeviceRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientdeauthorizedevicerequest(o CMsgClientDeauthorizeDeviceRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientdeauthorizedevicerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientDeauthorizeDeviceRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientdeauthorizedevicerequest_unpack(v)? +return i, unpacked +} +pub struct CMsgClientDeauthorizeDevice { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +deauthorization_account_id u32 +has_deauthorization_account_id bool +} +pub fn (o &CMsgClientDeauthorizeDevice) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_deauthorization_account_id { +res << vproto.pack_uint32_field(o.deauthorization_account_id, 2) +} + +return res +} + +pub fn cmsgclientdeauthorizedevice_unpack(buf []byte) ?CMsgClientDeauthorizeDevice { +mut res := CMsgClientDeauthorizeDevice{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_deauthorization_account_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.deauthorization_account_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientdeauthorizedevice() CMsgClientDeauthorizeDevice { +return CMsgClientDeauthorizeDevice{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientdeauthorizedevice(o CMsgClientDeauthorizeDevice, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientdeauthorizedevice(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientDeauthorizeDevice) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientdeauthorizedevice_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUseLocalDeviceAuthorizationsDeviceToken { +mut: +unknown_fields []vproto.UnknownField +pub mut: +owner_account_id u32 +has_owner_account_id bool +token_id u64 +has_token_id bool +} +pub fn (o &CMsgClientUseLocalDeviceAuthorizationsDeviceToken) pack() []byte { +mut res := []byte{} +if o.has_owner_account_id { +res << vproto.pack_uint32_field(o.owner_account_id, 1) +} + +if o.has_token_id { +res << vproto.pack_uint64_field(o.token_id, 2) +} + +return res +} + +pub fn cmsgclientuselocaldeviceauthorizationsdevicetoken_unpack(buf []byte) ?CMsgClientUseLocalDeviceAuthorizationsDeviceToken { +mut res := CMsgClientUseLocalDeviceAuthorizationsDeviceToken{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_owner_account_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.owner_account_id = v +i = ii +} + +2 { +res.has_token_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.token_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientuselocaldeviceauthorizationsdevicetoken() CMsgClientUseLocalDeviceAuthorizationsDeviceToken { +return CMsgClientUseLocalDeviceAuthorizationsDeviceToken{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientuselocaldeviceauthorizationsdevicetoken(o CMsgClientUseLocalDeviceAuthorizationsDeviceToken, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientuselocaldeviceauthorizationsdevicetoken(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUseLocalDeviceAuthorizationsDeviceToken) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientuselocaldeviceauthorizationsdevicetoken_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUseLocalDeviceAuthorizations { +mut: +unknown_fields []vproto.UnknownField +pub mut: +authorization_account_id []u32 +device_tokens []CMsgClientUseLocalDeviceAuthorizationsDeviceToken +} +pub fn (o &CMsgClientUseLocalDeviceAuthorizations) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.authorization_account_id { +res << vproto.pack_uint32_field(x, 1) +} + +// [packed=false] +for _, x in o.device_tokens { +res << zzz_vproto_internal_pack_cmsgclientuselocaldeviceauthorizationsdevicetoken(x, 2) +} + +return res +} + +pub fn cmsgclientuselocaldeviceauthorizations_unpack(buf []byte) ?CMsgClientUseLocalDeviceAuthorizations { +mut res := CMsgClientUseLocalDeviceAuthorizations{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.authorization_account_id << v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientuselocaldeviceauthorizationsdevicetoken(cur_buf, tag_wiretype.wire_type)? +res.device_tokens << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientuselocaldeviceauthorizations() CMsgClientUseLocalDeviceAuthorizations { +return CMsgClientUseLocalDeviceAuthorizations{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientuselocaldeviceauthorizations(o CMsgClientUseLocalDeviceAuthorizations, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientuselocaldeviceauthorizations(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUseLocalDeviceAuthorizations) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientuselocaldeviceauthorizations_unpack(v)? +return i, unpacked +} +pub struct CMsgClientGetAuthorizedDevices { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CMsgClientGetAuthorizedDevices) pack() []byte { +res := []byte{} +return res +} + +pub fn cmsgclientgetauthorizeddevices_unpack(buf []byte) ?CMsgClientGetAuthorizedDevices { +res := CMsgClientGetAuthorizedDevices{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientgetauthorizeddevices() CMsgClientGetAuthorizedDevices { +return CMsgClientGetAuthorizedDevices{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientgetauthorizeddevices(o CMsgClientGetAuthorizedDevices, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientgetauthorizeddevices(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientGetAuthorizedDevices) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientgetauthorizeddevices_unpack(v)? +return i, unpacked +} +pub struct CMsgClientGetAuthorizedDevicesResponseAuthorizedDevice { +mut: +unknown_fields []vproto.UnknownField +pub mut: +auth_device_token u64 +has_auth_device_token bool +device_name string +has_device_name bool +last_access_time u32 +has_last_access_time bool +borrower_id u32 +has_borrower_id bool +is_pending bool +has_is_pending bool +app_played u32 +has_app_played bool +} +pub fn (o &CMsgClientGetAuthorizedDevicesResponseAuthorizedDevice) pack() []byte { +mut res := []byte{} +if o.has_auth_device_token { +res << vproto.pack_uint64_field(o.auth_device_token, 1) +} + +if o.has_device_name { +res << vproto.pack_string_field(o.device_name, 2) +} + +if o.has_last_access_time { +res << vproto.pack_uint32_field(o.last_access_time, 3) +} + +if o.has_borrower_id { +res << vproto.pack_uint32_field(o.borrower_id, 4) +} + +if o.has_is_pending { +res << vproto.pack_bool_field(o.is_pending, 5) +} + +if o.has_app_played { +res << vproto.pack_uint32_field(o.app_played, 6) +} + +return res +} + +pub fn cmsgclientgetauthorizeddevicesresponseauthorizeddevice_unpack(buf []byte) ?CMsgClientGetAuthorizedDevicesResponseAuthorizedDevice { +mut res := CMsgClientGetAuthorizedDevicesResponseAuthorizedDevice{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_auth_device_token = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.auth_device_token = v +i = ii +} + +2 { +res.has_device_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.device_name = v +i = ii +} + +3 { +res.has_last_access_time = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_access_time = v +i = ii +} + +4 { +res.has_borrower_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.borrower_id = v +i = ii +} + +5 { +res.has_is_pending = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_pending = v +i = ii +} + +6 { +res.has_app_played = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_played = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientgetauthorizeddevicesresponseauthorizeddevice() CMsgClientGetAuthorizedDevicesResponseAuthorizedDevice { +return CMsgClientGetAuthorizedDevicesResponseAuthorizedDevice{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientgetauthorizeddevicesresponseauthorizeddevice(o CMsgClientGetAuthorizedDevicesResponseAuthorizedDevice, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientgetauthorizeddevicesresponseauthorizeddevice(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientGetAuthorizedDevicesResponseAuthorizedDevice) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientgetauthorizeddevicesresponseauthorizeddevice_unpack(v)? +return i, unpacked +} +pub struct CMsgClientGetAuthorizedDevicesResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +authorized_device []CMsgClientGetAuthorizedDevicesResponseAuthorizedDevice +} +pub fn (o &CMsgClientGetAuthorizedDevicesResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +// [packed=false] +for _, x in o.authorized_device { +res << zzz_vproto_internal_pack_cmsgclientgetauthorizeddevicesresponseauthorizeddevice(x, 2) +} + +return res +} + +pub fn cmsgclientgetauthorizeddevicesresponse_unpack(buf []byte) ?CMsgClientGetAuthorizedDevicesResponse { +mut res := CMsgClientGetAuthorizedDevicesResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientgetauthorizeddevicesresponseauthorizeddevice(cur_buf, tag_wiretype.wire_type)? +res.authorized_device << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientgetauthorizeddevicesresponse() CMsgClientGetAuthorizedDevicesResponse { +return CMsgClientGetAuthorizedDevicesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientgetauthorizeddevicesresponse(o CMsgClientGetAuthorizedDevicesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientgetauthorizeddevicesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientGetAuthorizedDevicesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientgetauthorizeddevicesresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientSharedLibraryLockStatusLockedLibrary { +mut: +unknown_fields []vproto.UnknownField +pub mut: +owner_id u32 +has_owner_id bool +locked_by u32 +has_locked_by bool +} +pub fn (o &CMsgClientSharedLibraryLockStatusLockedLibrary) pack() []byte { +mut res := []byte{} +if o.has_owner_id { +res << vproto.pack_uint32_field(o.owner_id, 1) +} + +if o.has_locked_by { +res << vproto.pack_uint32_field(o.locked_by, 2) +} + +return res +} + +pub fn cmsgclientsharedlibrarylockstatuslockedlibrary_unpack(buf []byte) ?CMsgClientSharedLibraryLockStatusLockedLibrary { +mut res := CMsgClientSharedLibraryLockStatusLockedLibrary{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_owner_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.owner_id = v +i = ii +} + +2 { +res.has_locked_by = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.locked_by = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientsharedlibrarylockstatuslockedlibrary() CMsgClientSharedLibraryLockStatusLockedLibrary { +return CMsgClientSharedLibraryLockStatusLockedLibrary{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientsharedlibrarylockstatuslockedlibrary(o CMsgClientSharedLibraryLockStatusLockedLibrary, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientsharedlibrarylockstatuslockedlibrary(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientSharedLibraryLockStatusLockedLibrary) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientsharedlibrarylockstatuslockedlibrary_unpack(v)? +return i, unpacked +} +pub struct CMsgClientSharedLibraryLockStatus { +mut: +unknown_fields []vproto.UnknownField +pub mut: +locked_library []CMsgClientSharedLibraryLockStatusLockedLibrary +own_library_locked_by u32 +has_own_library_locked_by bool +} +pub fn (o &CMsgClientSharedLibraryLockStatus) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.locked_library { +res << zzz_vproto_internal_pack_cmsgclientsharedlibrarylockstatuslockedlibrary(x, 1) +} + +if o.has_own_library_locked_by { +res << vproto.pack_uint32_field(o.own_library_locked_by, 2) +} + +return res +} + +pub fn cmsgclientsharedlibrarylockstatus_unpack(buf []byte) ?CMsgClientSharedLibraryLockStatus { +mut res := CMsgClientSharedLibraryLockStatus{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientsharedlibrarylockstatuslockedlibrary(cur_buf, tag_wiretype.wire_type)? +res.locked_library << v +i = ii +} + +2 { +res.has_own_library_locked_by = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.own_library_locked_by = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientsharedlibrarylockstatus() CMsgClientSharedLibraryLockStatus { +return CMsgClientSharedLibraryLockStatus{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientsharedlibrarylockstatus(o CMsgClientSharedLibraryLockStatus, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientsharedlibrarylockstatus(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientSharedLibraryLockStatus) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientsharedlibrarylockstatus_unpack(v)? +return i, unpacked +} +pub struct CMsgClientSharedLibraryStopPlayingStopApp { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +owner_id u32 +has_owner_id bool +} +pub fn (o &CMsgClientSharedLibraryStopPlayingStopApp) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_owner_id { +res << vproto.pack_uint32_field(o.owner_id, 2) +} + +return res +} + +pub fn cmsgclientsharedlibrarystopplayingstopapp_unpack(buf []byte) ?CMsgClientSharedLibraryStopPlayingStopApp { +mut res := CMsgClientSharedLibraryStopPlayingStopApp{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_owner_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.owner_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientsharedlibrarystopplayingstopapp() CMsgClientSharedLibraryStopPlayingStopApp { +return CMsgClientSharedLibraryStopPlayingStopApp{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientsharedlibrarystopplayingstopapp(o CMsgClientSharedLibraryStopPlayingStopApp, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientsharedlibrarystopplayingstopapp(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientSharedLibraryStopPlayingStopApp) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientsharedlibrarystopplayingstopapp_unpack(v)? +return i, unpacked +} +pub struct CMsgClientSharedLibraryStopPlaying { +mut: +unknown_fields []vproto.UnknownField +pub mut: +seconds_left int +has_seconds_left bool +stop_apps []CMsgClientSharedLibraryStopPlayingStopApp +} +pub fn (o &CMsgClientSharedLibraryStopPlaying) pack() []byte { +mut res := []byte{} +if o.has_seconds_left { +res << vproto.pack_int32_field(o.seconds_left, 1) +} + +// [packed=false] +for _, x in o.stop_apps { +res << zzz_vproto_internal_pack_cmsgclientsharedlibrarystopplayingstopapp(x, 2) +} + +return res +} + +pub fn cmsgclientsharedlibrarystopplaying_unpack(buf []byte) ?CMsgClientSharedLibraryStopPlaying { +mut res := CMsgClientSharedLibraryStopPlaying{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_seconds_left = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_left = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientsharedlibrarystopplayingstopapp(cur_buf, tag_wiretype.wire_type)? +res.stop_apps << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientsharedlibrarystopplaying() CMsgClientSharedLibraryStopPlaying { +return CMsgClientSharedLibraryStopPlaying{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientsharedlibrarystopplaying(o CMsgClientSharedLibraryStopPlaying, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientsharedlibrarystopplaying(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientSharedLibraryStopPlaying) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientsharedlibrarystopplaying_unpack(v)? +return i, unpacked +} +pub struct CMsgClientServiceCall { +mut: +unknown_fields []vproto.UnknownField +pub mut: +sysid_routing []byte +has_sysid_routing bool +call_handle u32 +has_call_handle bool +module_crc u32 +has_module_crc bool +module_hash []byte +has_module_hash bool +function_id u32 +has_function_id bool +cub_output_max u32 +has_cub_output_max bool +flags u32 +has_flags bool +callparameter []byte +has_callparameter bool +ping_only bool +has_ping_only bool +max_outstanding_calls u32 +has_max_outstanding_calls bool +} +pub fn (o &CMsgClientServiceCall) pack() []byte { +mut res := []byte{} +if o.has_sysid_routing { +res << vproto.pack_bytes_field(o.sysid_routing, 1) +} + +if o.has_call_handle { +res << vproto.pack_uint32_field(o.call_handle, 2) +} + +if o.has_module_crc { +res << vproto.pack_uint32_field(o.module_crc, 3) +} + +if o.has_module_hash { +res << vproto.pack_bytes_field(o.module_hash, 4) +} + +if o.has_function_id { +res << vproto.pack_uint32_field(o.function_id, 5) +} + +if o.has_cub_output_max { +res << vproto.pack_uint32_field(o.cub_output_max, 6) +} + +if o.has_flags { +res << vproto.pack_uint32_field(o.flags, 7) +} + +if o.has_callparameter { +res << vproto.pack_bytes_field(o.callparameter, 8) +} + +if o.has_ping_only { +res << vproto.pack_bool_field(o.ping_only, 9) +} + +if o.has_max_outstanding_calls { +res << vproto.pack_uint32_field(o.max_outstanding_calls, 10) +} + +return res +} + +pub fn cmsgclientservicecall_unpack(buf []byte) ?CMsgClientServiceCall { +mut res := CMsgClientServiceCall{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_sysid_routing = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sysid_routing = v +i = ii +} + +2 { +res.has_call_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.call_handle = v +i = ii +} + +3 { +res.has_module_crc = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.module_crc = v +i = ii +} + +4 { +res.has_module_hash = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.module_hash = v +i = ii +} + +5 { +res.has_function_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.function_id = v +i = ii +} + +6 { +res.has_cub_output_max = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cub_output_max = v +i = ii +} + +7 { +res.has_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.flags = v +i = ii +} + +8 { +res.has_callparameter = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.callparameter = v +i = ii +} + +9 { +res.has_ping_only = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.ping_only = v +i = ii +} + +10 { +res.has_max_outstanding_calls = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.max_outstanding_calls = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientservicecall() CMsgClientServiceCall { +return CMsgClientServiceCall{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientservicecall(o CMsgClientServiceCall, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientservicecall(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientServiceCall) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientservicecall_unpack(v)? +return i, unpacked +} +pub struct CMsgClientServiceModule { +mut: +unknown_fields []vproto.UnknownField +pub mut: +module_crc u32 +has_module_crc bool +module_hash []byte +has_module_hash bool +module_content []byte +has_module_content bool +} +pub fn (o &CMsgClientServiceModule) pack() []byte { +mut res := []byte{} +if o.has_module_crc { +res << vproto.pack_uint32_field(o.module_crc, 1) +} + +if o.has_module_hash { +res << vproto.pack_bytes_field(o.module_hash, 2) +} + +if o.has_module_content { +res << vproto.pack_bytes_field(o.module_content, 3) +} + +return res +} + +pub fn cmsgclientservicemodule_unpack(buf []byte) ?CMsgClientServiceModule { +mut res := CMsgClientServiceModule{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_module_crc = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.module_crc = v +i = ii +} + +2 { +res.has_module_hash = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.module_hash = v +i = ii +} + +3 { +res.has_module_content = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.module_content = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientservicemodule() CMsgClientServiceModule { +return CMsgClientServiceModule{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientservicemodule(o CMsgClientServiceModule, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientservicemodule(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientServiceModule) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientservicemodule_unpack(v)? +return i, unpacked +} +pub struct CMsgClientServiceCallResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +sysid_routing []byte +has_sysid_routing bool +call_handle u32 +has_call_handle bool +module_crc u32 +has_module_crc bool +module_hash []byte +has_module_hash bool +ecallresult u32 +has_ecallresult bool +result_content []byte +has_result_content bool +os_version_info []byte +has_os_version_info bool +system_info []byte +has_system_info bool +load_address u64 +has_load_address bool +exception_record []byte +has_exception_record bool +portable_os_version_info []byte +has_portable_os_version_info bool +portable_system_info []byte +has_portable_system_info bool +was_converted bool +has_was_converted bool +internal_result u32 +has_internal_result bool +current_count u32 +has_current_count bool +last_call_handle u32 +has_last_call_handle bool +last_call_module_crc u32 +has_last_call_module_crc bool +last_call_sysid_routing []byte +has_last_call_sysid_routing bool +last_ecallresult u32 +has_last_ecallresult bool +last_callissue_delta u32 +has_last_callissue_delta bool +last_callcomplete_delta u32 +has_last_callcomplete_delta bool +} +pub fn (o &CMsgClientServiceCallResponse) pack() []byte { +mut res := []byte{} +if o.has_sysid_routing { +res << vproto.pack_bytes_field(o.sysid_routing, 1) +} + +if o.has_call_handle { +res << vproto.pack_uint32_field(o.call_handle, 2) +} + +if o.has_module_crc { +res << vproto.pack_uint32_field(o.module_crc, 3) +} + +if o.has_module_hash { +res << vproto.pack_bytes_field(o.module_hash, 4) +} + +if o.has_ecallresult { +res << vproto.pack_uint32_field(o.ecallresult, 5) +} + +if o.has_result_content { +res << vproto.pack_bytes_field(o.result_content, 6) +} + +if o.has_os_version_info { +res << vproto.pack_bytes_field(o.os_version_info, 7) +} + +if o.has_system_info { +res << vproto.pack_bytes_field(o.system_info, 8) +} + +if o.has_load_address { +res << vproto.pack_64bit_field(o.load_address, 9) +} + +if o.has_exception_record { +res << vproto.pack_bytes_field(o.exception_record, 10) +} + +if o.has_portable_os_version_info { +res << vproto.pack_bytes_field(o.portable_os_version_info, 11) +} + +if o.has_portable_system_info { +res << vproto.pack_bytes_field(o.portable_system_info, 12) +} + +if o.has_was_converted { +res << vproto.pack_bool_field(o.was_converted, 13) +} + +if o.has_internal_result { +res << vproto.pack_uint32_field(o.internal_result, 14) +} + +if o.has_current_count { +res << vproto.pack_uint32_field(o.current_count, 15) +} + +if o.has_last_call_handle { +res << vproto.pack_uint32_field(o.last_call_handle, 16) +} + +if o.has_last_call_module_crc { +res << vproto.pack_uint32_field(o.last_call_module_crc, 17) +} + +if o.has_last_call_sysid_routing { +res << vproto.pack_bytes_field(o.last_call_sysid_routing, 18) +} + +if o.has_last_ecallresult { +res << vproto.pack_uint32_field(o.last_ecallresult, 19) +} + +if o.has_last_callissue_delta { +res << vproto.pack_uint32_field(o.last_callissue_delta, 20) +} + +if o.has_last_callcomplete_delta { +res << vproto.pack_uint32_field(o.last_callcomplete_delta, 21) +} + +return res +} + +pub fn cmsgclientservicecallresponse_unpack(buf []byte) ?CMsgClientServiceCallResponse { +mut res := CMsgClientServiceCallResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_sysid_routing = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sysid_routing = v +i = ii +} + +2 { +res.has_call_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.call_handle = v +i = ii +} + +3 { +res.has_module_crc = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.module_crc = v +i = ii +} + +4 { +res.has_module_hash = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.module_hash = v +i = ii +} + +5 { +res.has_ecallresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ecallresult = v +i = ii +} + +6 { +res.has_result_content = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.result_content = v +i = ii +} + +7 { +res.has_os_version_info = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.os_version_info = v +i = ii +} + +8 { +res.has_system_info = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.system_info = v +i = ii +} + +9 { +res.has_load_address = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.load_address = v +i = ii +} + +10 { +res.has_exception_record = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.exception_record = v +i = ii +} + +11 { +res.has_portable_os_version_info = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.portable_os_version_info = v +i = ii +} + +12 { +res.has_portable_system_info = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.portable_system_info = v +i = ii +} + +13 { +res.has_was_converted = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.was_converted = v +i = ii +} + +14 { +res.has_internal_result = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.internal_result = v +i = ii +} + +15 { +res.has_current_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.current_count = v +i = ii +} + +16 { +res.has_last_call_handle = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_call_handle = v +i = ii +} + +17 { +res.has_last_call_module_crc = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_call_module_crc = v +i = ii +} + +18 { +res.has_last_call_sysid_routing = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.last_call_sysid_routing = v +i = ii +} + +19 { +res.has_last_ecallresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_ecallresult = v +i = ii +} + +20 { +res.has_last_callissue_delta = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_callissue_delta = v +i = ii +} + +21 { +res.has_last_callcomplete_delta = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_callcomplete_delta = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientservicecallresponse() CMsgClientServiceCallResponse { +return CMsgClientServiceCallResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientservicecallresponse(o CMsgClientServiceCallResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientservicecallresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientServiceCallResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientservicecallresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgAMunlockStreaming { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CMsgAMunlockStreaming) pack() []byte { +res := []byte{} +return res +} + +pub fn cmsgamunlockstreaming_unpack(buf []byte) ?CMsgAMunlockStreaming { +res := CMsgAMunlockStreaming{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgamunlockstreaming() CMsgAMunlockStreaming { +return CMsgAMunlockStreaming{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgamunlockstreaming(o CMsgAMunlockStreaming, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgamunlockstreaming(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgAMunlockStreaming) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgamunlockstreaming_unpack(v)? +return i, unpacked +} +pub struct CMsgAMunlockStreamingResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +encryption_key []byte +has_encryption_key bool +} +pub fn (o &CMsgAMunlockStreamingResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_encryption_key { +res << vproto.pack_bytes_field(o.encryption_key, 2) +} + +return res +} + +pub fn cmsgamunlockstreamingresponse_unpack(buf []byte) ?CMsgAMunlockStreamingResponse { +mut res := CMsgAMunlockStreamingResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_encryption_key = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.encryption_key = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgamunlockstreamingresponse() CMsgAMunlockStreamingResponse { +return CMsgAMunlockStreamingResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgamunlockstreamingresponse(o CMsgAMunlockStreamingResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgamunlockstreamingresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgAMunlockStreamingResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgamunlockstreamingresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgAMunlockHEvc { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CMsgAMunlockHEvc) pack() []byte { +res := []byte{} +return res +} + +pub fn cmsgamunlockhevc_unpack(buf []byte) ?CMsgAMunlockHEvc { +res := CMsgAMunlockHEvc{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgamunlockhevc() CMsgAMunlockHEvc { +return CMsgAMunlockHEvc{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgamunlockhevc(o CMsgAMunlockHEvc, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgamunlockhevc(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgAMunlockHEvc) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgamunlockhevc_unpack(v)? +return i, unpacked +} +pub struct CMsgAMunlockHEvcresponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +} +pub fn (o &CMsgAMunlockHEvcresponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +return res +} + +pub fn cmsgamunlockhevcresponse_unpack(buf []byte) ?CMsgAMunlockHEvcresponse { +mut res := CMsgAMunlockHEvcresponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgamunlockhevcresponse() CMsgAMunlockHEvcresponse { +return CMsgAMunlockHEvcresponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgamunlockhevcresponse(o CMsgAMunlockHEvcresponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgamunlockhevcresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgAMunlockHEvcresponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgamunlockhevcresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientPlayingSessionState { +mut: +unknown_fields []vproto.UnknownField +pub mut: +playing_blocked bool +has_playing_blocked bool +playing_app u32 +has_playing_app bool +} +pub fn (o &CMsgClientPlayingSessionState) pack() []byte { +mut res := []byte{} +if o.has_playing_blocked { +res << vproto.pack_bool_field(o.playing_blocked, 2) +} + +if o.has_playing_app { +res << vproto.pack_uint32_field(o.playing_app, 3) +} + +return res +} + +pub fn cmsgclientplayingsessionstate_unpack(buf []byte) ?CMsgClientPlayingSessionState { +mut res := CMsgClientPlayingSessionState{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +2 { +res.has_playing_blocked = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.playing_blocked = v +i = ii +} + +3 { +res.has_playing_app = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.playing_app = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientplayingsessionstate() CMsgClientPlayingSessionState { +return CMsgClientPlayingSessionState{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientplayingsessionstate(o CMsgClientPlayingSessionState, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientplayingsessionstate(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientPlayingSessionState) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientplayingsessionstate_unpack(v)? +return i, unpacked +} +pub struct CMsgClientKickPlayingSession { +mut: +unknown_fields []vproto.UnknownField +pub mut: +only_stop_game bool +has_only_stop_game bool +} +pub fn (o &CMsgClientKickPlayingSession) pack() []byte { +mut res := []byte{} +if o.has_only_stop_game { +res << vproto.pack_bool_field(o.only_stop_game, 1) +} + +return res +} + +pub fn cmsgclientkickplayingsession_unpack(buf []byte) ?CMsgClientKickPlayingSession { +mut res := CMsgClientKickPlayingSession{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_only_stop_game = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.only_stop_game = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientkickplayingsession() CMsgClientKickPlayingSession { +return CMsgClientKickPlayingSession{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientkickplayingsession(o CMsgClientKickPlayingSession, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientkickplayingsession(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientKickPlayingSession) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientkickplayingsession_unpack(v)? +return i, unpacked +} +pub struct CMsgClientVoiceCallPreAuthorize { +mut: +unknown_fields []vproto.UnknownField +pub mut: +caller_steamid u64 +has_caller_steamid bool +receiver_steamid u64 +has_receiver_steamid bool +caller_id int +has_caller_id bool +hangup bool +has_hangup bool +} +pub fn (o &CMsgClientVoiceCallPreAuthorize) pack() []byte { +mut res := []byte{} +if o.has_caller_steamid { +res << vproto.pack_64bit_field(o.caller_steamid, 1) +} + +if o.has_receiver_steamid { +res << vproto.pack_64bit_field(o.receiver_steamid, 2) +} + +if o.has_caller_id { +res << vproto.pack_int32_field(o.caller_id, 3) +} + +if o.has_hangup { +res << vproto.pack_bool_field(o.hangup, 4) +} + +return res +} + +pub fn cmsgclientvoicecallpreauthorize_unpack(buf []byte) ?CMsgClientVoiceCallPreAuthorize { +mut res := CMsgClientVoiceCallPreAuthorize{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_caller_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.caller_steamid = v +i = ii +} + +2 { +res.has_receiver_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.receiver_steamid = v +i = ii +} + +3 { +res.has_caller_id = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.caller_id = v +i = ii +} + +4 { +res.has_hangup = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.hangup = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientvoicecallpreauthorize() CMsgClientVoiceCallPreAuthorize { +return CMsgClientVoiceCallPreAuthorize{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientvoicecallpreauthorize(o CMsgClientVoiceCallPreAuthorize, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientvoicecallpreauthorize(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientVoiceCallPreAuthorize) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientvoicecallpreauthorize_unpack(v)? +return i, unpacked +} +pub struct CMsgClientVoiceCallPreAuthorizeResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +caller_steamid u64 +has_caller_steamid bool +receiver_steamid u64 +has_receiver_steamid bool +eresult int +has_eresult bool +caller_id int +has_caller_id bool +} +pub fn (o &CMsgClientVoiceCallPreAuthorizeResponse) pack() []byte { +mut res := []byte{} +if o.has_caller_steamid { +res << vproto.pack_64bit_field(o.caller_steamid, 1) +} + +if o.has_receiver_steamid { +res << vproto.pack_64bit_field(o.receiver_steamid, 2) +} + +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 3) +} + +if o.has_caller_id { +res << vproto.pack_int32_field(o.caller_id, 4) +} + +return res +} + +pub fn cmsgclientvoicecallpreauthorizeresponse_unpack(buf []byte) ?CMsgClientVoiceCallPreAuthorizeResponse { +mut res := CMsgClientVoiceCallPreAuthorizeResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_caller_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.caller_steamid = v +i = ii +} + +2 { +res.has_receiver_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.receiver_steamid = v +i = ii +} + +3 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +4 { +res.has_caller_id = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.caller_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientvoicecallpreauthorizeresponse() CMsgClientVoiceCallPreAuthorizeResponse { +return CMsgClientVoiceCallPreAuthorizeResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientvoicecallpreauthorizeresponse(o CMsgClientVoiceCallPreAuthorizeResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientvoicecallpreauthorizeresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientVoiceCallPreAuthorizeResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientvoicecallpreauthorizeresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgBadgeCraftedNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +badge_level u32 +has_badge_level bool +} +pub fn (o &CMsgBadgeCraftedNotification) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_badge_level { +res << vproto.pack_uint32_field(o.badge_level, 2) +} + +return res +} + +pub fn cmsgbadgecraftednotification_unpack(buf []byte) ?CMsgBadgeCraftedNotification { +mut res := CMsgBadgeCraftedNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_badge_level = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.badge_level = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgbadgecraftednotification() CMsgBadgeCraftedNotification { +return CMsgBadgeCraftedNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgbadgecraftednotification(o CMsgBadgeCraftedNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgbadgecraftednotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgBadgeCraftedNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgbadgecraftednotification_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_clientserver_friends_pb.v b/proto/steammessages_clientserver_friends_pb.v new file mode 100644 index 0000000..4cc0b05 --- /dev/null +++ b/proto/steammessages_clientserver_friends_pb.v @@ -0,0 +1,3474 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CMsgClientFriendMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +chat_entry_type int +has_chat_entry_type bool +message []byte +has_message bool +rtime32_server_timestamp u32 +has_rtime32_server_timestamp bool +echo_to_sender bool +has_echo_to_sender bool +} +pub fn (o &CMsgClientFriendMsg) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_chat_entry_type { +res << vproto.pack_int32_field(o.chat_entry_type, 2) +} + +if o.has_message { +res << vproto.pack_bytes_field(o.message, 3) +} + +if o.has_rtime32_server_timestamp { +res << vproto.pack_32bit_field(o.rtime32_server_timestamp, 4) +} + +if o.has_echo_to_sender { +res << vproto.pack_bool_field(o.echo_to_sender, 5) +} + +return res +} + +pub fn cmsgclientfriendmsg_unpack(buf []byte) ?CMsgClientFriendMsg { +mut res := CMsgClientFriendMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_chat_entry_type = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.chat_entry_type = v +i = ii +} + +3 { +res.has_message = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.message = v +i = ii +} + +4 { +res.has_rtime32_server_timestamp = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.rtime32_server_timestamp = v +i = ii +} + +5 { +res.has_echo_to_sender = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.echo_to_sender = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientfriendmsg() CMsgClientFriendMsg { +return CMsgClientFriendMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientfriendmsg(o CMsgClientFriendMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientfriendmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientFriendMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientfriendmsg_unpack(v)? +return i, unpacked +} +pub struct CMsgClientFriendMsgIncoming { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid_from u64 +has_steamid_from bool +chat_entry_type int +has_chat_entry_type bool +from_limited_account bool +has_from_limited_account bool +message []byte +has_message bool +rtime32_server_timestamp u32 +has_rtime32_server_timestamp bool +} +pub fn (o &CMsgClientFriendMsgIncoming) pack() []byte { +mut res := []byte{} +if o.has_steamid_from { +res << vproto.pack_64bit_field(o.steamid_from, 1) +} + +if o.has_chat_entry_type { +res << vproto.pack_int32_field(o.chat_entry_type, 2) +} + +if o.has_from_limited_account { +res << vproto.pack_bool_field(o.from_limited_account, 3) +} + +if o.has_message { +res << vproto.pack_bytes_field(o.message, 4) +} + +if o.has_rtime32_server_timestamp { +res << vproto.pack_32bit_field(o.rtime32_server_timestamp, 5) +} + +return res +} + +pub fn cmsgclientfriendmsgincoming_unpack(buf []byte) ?CMsgClientFriendMsgIncoming { +mut res := CMsgClientFriendMsgIncoming{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid_from = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_from = v +i = ii +} + +2 { +res.has_chat_entry_type = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.chat_entry_type = v +i = ii +} + +3 { +res.has_from_limited_account = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.from_limited_account = v +i = ii +} + +4 { +res.has_message = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.message = v +i = ii +} + +5 { +res.has_rtime32_server_timestamp = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.rtime32_server_timestamp = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientfriendmsgincoming() CMsgClientFriendMsgIncoming { +return CMsgClientFriendMsgIncoming{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientfriendmsgincoming(o CMsgClientFriendMsgIncoming, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientfriendmsgincoming(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientFriendMsgIncoming) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientfriendmsgincoming_unpack(v)? +return i, unpacked +} +pub struct CMsgClientAddFriend { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid_to_add u64 +has_steamid_to_add bool +accountname_or_email_to_add string +has_accountname_or_email_to_add bool +} +pub fn (o &CMsgClientAddFriend) pack() []byte { +mut res := []byte{} +if o.has_steamid_to_add { +res << vproto.pack_64bit_field(o.steamid_to_add, 1) +} + +if o.has_accountname_or_email_to_add { +res << vproto.pack_string_field(o.accountname_or_email_to_add, 2) +} + +return res +} + +pub fn cmsgclientaddfriend_unpack(buf []byte) ?CMsgClientAddFriend { +mut res := CMsgClientAddFriend{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid_to_add = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_to_add = v +i = ii +} + +2 { +res.has_accountname_or_email_to_add = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.accountname_or_email_to_add = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientaddfriend() CMsgClientAddFriend { +return CMsgClientAddFriend{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientaddfriend(o CMsgClientAddFriend, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientaddfriend(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientAddFriend) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientaddfriend_unpack(v)? +return i, unpacked +} +pub struct CMsgClientAddFriendResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +steam_id_added u64 +has_steam_id_added bool +persona_name_added string +has_persona_name_added bool +} +pub fn (o &CMsgClientAddFriendResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_steam_id_added { +res << vproto.pack_64bit_field(o.steam_id_added, 2) +} + +if o.has_persona_name_added { +res << vproto.pack_string_field(o.persona_name_added, 3) +} + +return res +} + +pub fn cmsgclientaddfriendresponse_unpack(buf []byte) ?CMsgClientAddFriendResponse { +mut res := CMsgClientAddFriendResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_steam_id_added = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_added = v +i = ii +} + +3 { +res.has_persona_name_added = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.persona_name_added = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientaddfriendresponse() CMsgClientAddFriendResponse { +return CMsgClientAddFriendResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientaddfriendresponse(o CMsgClientAddFriendResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientaddfriendresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientAddFriendResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientaddfriendresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRemoveFriend { +mut: +unknown_fields []vproto.UnknownField +pub mut: +friendid u64 +has_friendid bool +} +pub fn (o &CMsgClientRemoveFriend) pack() []byte { +mut res := []byte{} +if o.has_friendid { +res << vproto.pack_64bit_field(o.friendid, 1) +} + +return res +} + +pub fn cmsgclientremovefriend_unpack(buf []byte) ?CMsgClientRemoveFriend { +mut res := CMsgClientRemoveFriend{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_friendid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.friendid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientremovefriend() CMsgClientRemoveFriend { +return CMsgClientRemoveFriend{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientremovefriend(o CMsgClientRemoveFriend, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientremovefriend(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRemoveFriend) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientremovefriend_unpack(v)? +return i, unpacked +} +pub struct CMsgClientHideFriend { +mut: +unknown_fields []vproto.UnknownField +pub mut: +friendid u64 +has_friendid bool +hide bool +has_hide bool +} +pub fn (o &CMsgClientHideFriend) pack() []byte { +mut res := []byte{} +if o.has_friendid { +res << vproto.pack_64bit_field(o.friendid, 1) +} + +if o.has_hide { +res << vproto.pack_bool_field(o.hide, 2) +} + +return res +} + +pub fn cmsgclienthidefriend_unpack(buf []byte) ?CMsgClientHideFriend { +mut res := CMsgClientHideFriend{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_friendid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.friendid = v +i = ii +} + +2 { +res.has_hide = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.hide = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclienthidefriend() CMsgClientHideFriend { +return CMsgClientHideFriend{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclienthidefriend(o CMsgClientHideFriend, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclienthidefriend(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientHideFriend) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclienthidefriend_unpack(v)? +return i, unpacked +} +pub struct CMsgClientFriendsListFriend { +mut: +unknown_fields []vproto.UnknownField +pub mut: +ulfriendid u64 +has_ulfriendid bool +efriendrelationship u32 +has_efriendrelationship bool +} +pub fn (o &CMsgClientFriendsListFriend) pack() []byte { +mut res := []byte{} +if o.has_ulfriendid { +res << vproto.pack_64bit_field(o.ulfriendid, 1) +} + +if o.has_efriendrelationship { +res << vproto.pack_uint32_field(o.efriendrelationship, 2) +} + +return res +} + +pub fn cmsgclientfriendslistfriend_unpack(buf []byte) ?CMsgClientFriendsListFriend { +mut res := CMsgClientFriendsListFriend{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_ulfriendid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.ulfriendid = v +i = ii +} + +2 { +res.has_efriendrelationship = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.efriendrelationship = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientfriendslistfriend() CMsgClientFriendsListFriend { +return CMsgClientFriendsListFriend{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientfriendslistfriend(o CMsgClientFriendsListFriend, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientfriendslistfriend(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientFriendsListFriend) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientfriendslistfriend_unpack(v)? +return i, unpacked +} +pub struct CMsgClientFriendsList { +mut: +unknown_fields []vproto.UnknownField +pub mut: +bincremental bool +has_bincremental bool +friends []CMsgClientFriendsListFriend +max_friend_count u32 +has_max_friend_count bool +active_friend_count u32 +has_active_friend_count bool +friends_limit_hit bool +has_friends_limit_hit bool +} +pub fn (o &CMsgClientFriendsList) pack() []byte { +mut res := []byte{} +if o.has_bincremental { +res << vproto.pack_bool_field(o.bincremental, 1) +} + +// [packed=false] +for _, x in o.friends { +res << zzz_vproto_internal_pack_cmsgclientfriendslistfriend(x, 2) +} + +if o.has_max_friend_count { +res << vproto.pack_uint32_field(o.max_friend_count, 3) +} + +if o.has_active_friend_count { +res << vproto.pack_uint32_field(o.active_friend_count, 4) +} + +if o.has_friends_limit_hit { +res << vproto.pack_bool_field(o.friends_limit_hit, 5) +} + +return res +} + +pub fn cmsgclientfriendslist_unpack(buf []byte) ?CMsgClientFriendsList { +mut res := CMsgClientFriendsList{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_bincremental = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.bincremental = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientfriendslistfriend(cur_buf, tag_wiretype.wire_type)? +res.friends << v +i = ii +} + +3 { +res.has_max_friend_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.max_friend_count = v +i = ii +} + +4 { +res.has_active_friend_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.active_friend_count = v +i = ii +} + +5 { +res.has_friends_limit_hit = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.friends_limit_hit = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientfriendslist() CMsgClientFriendsList { +return CMsgClientFriendsList{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientfriendslist(o CMsgClientFriendsList, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientfriendslist(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientFriendsList) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientfriendslist_unpack(v)? +return i, unpacked +} +pub struct CMsgClientFriendsGroupsListFriendGroup { +mut: +unknown_fields []vproto.UnknownField +pub mut: +ngroupid int +has_ngroupid bool +strgroupname string +has_strgroupname bool +} +pub fn (o &CMsgClientFriendsGroupsListFriendGroup) pack() []byte { +mut res := []byte{} +if o.has_ngroupid { +res << vproto.pack_int32_field(o.ngroupid, 1) +} + +if o.has_strgroupname { +res << vproto.pack_string_field(o.strgroupname, 2) +} + +return res +} + +pub fn cmsgclientfriendsgroupslistfriendgroup_unpack(buf []byte) ?CMsgClientFriendsGroupsListFriendGroup { +mut res := CMsgClientFriendsGroupsListFriendGroup{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_ngroupid = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.ngroupid = v +i = ii +} + +2 { +res.has_strgroupname = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.strgroupname = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientfriendsgroupslistfriendgroup() CMsgClientFriendsGroupsListFriendGroup { +return CMsgClientFriendsGroupsListFriendGroup{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientfriendsgroupslistfriendgroup(o CMsgClientFriendsGroupsListFriendGroup, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientfriendsgroupslistfriendgroup(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientFriendsGroupsListFriendGroup) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientfriendsgroupslistfriendgroup_unpack(v)? +return i, unpacked +} +pub struct CMsgClientFriendsGroupsListFriendGroupsMembership { +mut: +unknown_fields []vproto.UnknownField +pub mut: +ulsteamid u64 +has_ulsteamid bool +ngroupid int +has_ngroupid bool +} +pub fn (o &CMsgClientFriendsGroupsListFriendGroupsMembership) pack() []byte { +mut res := []byte{} +if o.has_ulsteamid { +res << vproto.pack_64bit_field(o.ulsteamid, 1) +} + +if o.has_ngroupid { +res << vproto.pack_int32_field(o.ngroupid, 2) +} + +return res +} + +pub fn cmsgclientfriendsgroupslistfriendgroupsmembership_unpack(buf []byte) ?CMsgClientFriendsGroupsListFriendGroupsMembership { +mut res := CMsgClientFriendsGroupsListFriendGroupsMembership{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_ulsteamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.ulsteamid = v +i = ii +} + +2 { +res.has_ngroupid = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.ngroupid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientfriendsgroupslistfriendgroupsmembership() CMsgClientFriendsGroupsListFriendGroupsMembership { +return CMsgClientFriendsGroupsListFriendGroupsMembership{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientfriendsgroupslistfriendgroupsmembership(o CMsgClientFriendsGroupsListFriendGroupsMembership, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientfriendsgroupslistfriendgroupsmembership(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientFriendsGroupsListFriendGroupsMembership) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientfriendsgroupslistfriendgroupsmembership_unpack(v)? +return i, unpacked +} +pub struct CMsgClientFriendsGroupsList { +mut: +unknown_fields []vproto.UnknownField +pub mut: +bremoval bool +has_bremoval bool +bincremental bool +has_bincremental bool +friendgroups []CMsgClientFriendsGroupsListFriendGroup +memberships []CMsgClientFriendsGroupsListFriendGroupsMembership +} +pub fn (o &CMsgClientFriendsGroupsList) pack() []byte { +mut res := []byte{} +if o.has_bremoval { +res << vproto.pack_bool_field(o.bremoval, 1) +} + +if o.has_bincremental { +res << vproto.pack_bool_field(o.bincremental, 2) +} + +// [packed=false] +for _, x in o.friendgroups { +res << zzz_vproto_internal_pack_cmsgclientfriendsgroupslistfriendgroup(x, 3) +} + +// [packed=false] +for _, x in o.memberships { +res << zzz_vproto_internal_pack_cmsgclientfriendsgroupslistfriendgroupsmembership(x, 4) +} + +return res +} + +pub fn cmsgclientfriendsgroupslist_unpack(buf []byte) ?CMsgClientFriendsGroupsList { +mut res := CMsgClientFriendsGroupsList{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_bremoval = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.bremoval = v +i = ii +} + +2 { +res.has_bincremental = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.bincremental = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientfriendsgroupslistfriendgroup(cur_buf, tag_wiretype.wire_type)? +res.friendgroups << v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientfriendsgroupslistfriendgroupsmembership(cur_buf, tag_wiretype.wire_type)? +res.memberships << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientfriendsgroupslist() CMsgClientFriendsGroupsList { +return CMsgClientFriendsGroupsList{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientfriendsgroupslist(o CMsgClientFriendsGroupsList, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientfriendsgroupslist(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientFriendsGroupsList) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientfriendsgroupslist_unpack(v)? +return i, unpacked +} +pub struct CMsgClientPlayerNicknameListPlayerNickname { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +nickname string +has_nickname bool +} +pub fn (o &CMsgClientPlayerNicknameListPlayerNickname) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_nickname { +res << vproto.pack_string_field(o.nickname, 3) +} + +return res +} + +pub fn cmsgclientplayernicknamelistplayernickname_unpack(buf []byte) ?CMsgClientPlayerNicknameListPlayerNickname { +mut res := CMsgClientPlayerNicknameListPlayerNickname{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +3 { +res.has_nickname = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.nickname = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientplayernicknamelistplayernickname() CMsgClientPlayerNicknameListPlayerNickname { +return CMsgClientPlayerNicknameListPlayerNickname{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientplayernicknamelistplayernickname(o CMsgClientPlayerNicknameListPlayerNickname, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientplayernicknamelistplayernickname(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientPlayerNicknameListPlayerNickname) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientplayernicknamelistplayernickname_unpack(v)? +return i, unpacked +} +pub struct CMsgClientPlayerNicknameList { +mut: +unknown_fields []vproto.UnknownField +pub mut: +removal bool +has_removal bool +incremental bool +has_incremental bool +nicknames []CMsgClientPlayerNicknameListPlayerNickname +} +pub fn (o &CMsgClientPlayerNicknameList) pack() []byte { +mut res := []byte{} +if o.has_removal { +res << vproto.pack_bool_field(o.removal, 1) +} + +if o.has_incremental { +res << vproto.pack_bool_field(o.incremental, 2) +} + +// [packed=false] +for _, x in o.nicknames { +res << zzz_vproto_internal_pack_cmsgclientplayernicknamelistplayernickname(x, 3) +} + +return res +} + +pub fn cmsgclientplayernicknamelist_unpack(buf []byte) ?CMsgClientPlayerNicknameList { +mut res := CMsgClientPlayerNicknameList{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_removal = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.removal = v +i = ii +} + +2 { +res.has_incremental = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.incremental = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientplayernicknamelistplayernickname(cur_buf, tag_wiretype.wire_type)? +res.nicknames << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientplayernicknamelist() CMsgClientPlayerNicknameList { +return CMsgClientPlayerNicknameList{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientplayernicknamelist(o CMsgClientPlayerNicknameList, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientplayernicknamelist(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientPlayerNicknameList) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientplayernicknamelist_unpack(v)? +return i, unpacked +} +pub struct CMsgClientSetPlayerNickname { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +nickname string +has_nickname bool +} +pub fn (o &CMsgClientSetPlayerNickname) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_nickname { +res << vproto.pack_string_field(o.nickname, 2) +} + +return res +} + +pub fn cmsgclientsetplayernickname_unpack(buf []byte) ?CMsgClientSetPlayerNickname { +mut res := CMsgClientSetPlayerNickname{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_nickname = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.nickname = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientsetplayernickname() CMsgClientSetPlayerNickname { +return CMsgClientSetPlayerNickname{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientsetplayernickname(o CMsgClientSetPlayerNickname, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientsetplayernickname(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientSetPlayerNickname) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientsetplayernickname_unpack(v)? +return i, unpacked +} +pub struct CMsgClientSetPlayerNicknameResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult u32 +has_eresult bool +} +pub fn (o &CMsgClientSetPlayerNicknameResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_uint32_field(o.eresult, 1) +} + +return res +} + +pub fn cmsgclientsetplayernicknameresponse_unpack(buf []byte) ?CMsgClientSetPlayerNicknameResponse { +mut res := CMsgClientSetPlayerNicknameResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientsetplayernicknameresponse() CMsgClientSetPlayerNicknameResponse { +return CMsgClientSetPlayerNicknameResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientsetplayernicknameresponse(o CMsgClientSetPlayerNicknameResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientsetplayernicknameresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientSetPlayerNicknameResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientsetplayernicknameresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRequestFriendData { +mut: +unknown_fields []vproto.UnknownField +pub mut: +persona_state_requested u32 +has_persona_state_requested bool +friends []u64 +} +pub fn (o &CMsgClientRequestFriendData) pack() []byte { +mut res := []byte{} +if o.has_persona_state_requested { +res << vproto.pack_uint32_field(o.persona_state_requested, 1) +} + +// [packed=false] +for _, x in o.friends { +res << vproto.pack_64bit_field(x, 2) +} + +return res +} + +pub fn cmsgclientrequestfrienddata_unpack(buf []byte) ?CMsgClientRequestFriendData { +mut res := CMsgClientRequestFriendData{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_persona_state_requested = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.persona_state_requested = v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.friends << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientrequestfrienddata() CMsgClientRequestFriendData { +return CMsgClientRequestFriendData{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientrequestfrienddata(o CMsgClientRequestFriendData, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientrequestfrienddata(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRequestFriendData) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientrequestfrienddata_unpack(v)? +return i, unpacked +} +pub struct CMsgClientChangeStatus { +mut: +unknown_fields []vproto.UnknownField +pub mut: +persona_state u32 +has_persona_state bool +player_name string +has_player_name bool +is_auto_generated_name bool +has_is_auto_generated_name bool +high_priority bool +has_high_priority bool +persona_set_by_user bool +has_persona_set_by_user bool +persona_state_flags u32 +has_persona_state_flags bool +need_persona_response bool +has_need_persona_response bool +is_client_idle bool +has_is_client_idle bool +} +pub fn (o &CMsgClientChangeStatus) pack() []byte { +mut res := []byte{} +if o.has_persona_state { +res << vproto.pack_uint32_field(o.persona_state, 1) +} + +if o.has_player_name { +res << vproto.pack_string_field(o.player_name, 2) +} + +if o.has_is_auto_generated_name { +res << vproto.pack_bool_field(o.is_auto_generated_name, 3) +} + +if o.has_high_priority { +res << vproto.pack_bool_field(o.high_priority, 4) +} + +if o.has_persona_set_by_user { +res << vproto.pack_bool_field(o.persona_set_by_user, 5) +} + +if o.has_persona_state_flags { +res << vproto.pack_uint32_field(o.persona_state_flags, 6) +} + +if o.has_need_persona_response { +res << vproto.pack_bool_field(o.need_persona_response, 7) +} + +if o.has_is_client_idle { +res << vproto.pack_bool_field(o.is_client_idle, 8) +} + +return res +} + +pub fn cmsgclientchangestatus_unpack(buf []byte) ?CMsgClientChangeStatus { +mut res := CMsgClientChangeStatus{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_persona_state = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.persona_state = v +i = ii +} + +2 { +res.has_player_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.player_name = v +i = ii +} + +3 { +res.has_is_auto_generated_name = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_auto_generated_name = v +i = ii +} + +4 { +res.has_high_priority = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.high_priority = v +i = ii +} + +5 { +res.has_persona_set_by_user = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.persona_set_by_user = v +i = ii +} + +6 { +res.has_persona_state_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.persona_state_flags = v +i = ii +} + +7 { +res.has_need_persona_response = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.need_persona_response = v +i = ii +} + +8 { +res.has_is_client_idle = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_client_idle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientchangestatus() CMsgClientChangeStatus { +return CMsgClientChangeStatus{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientchangestatus(o CMsgClientChangeStatus, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientchangestatus(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientChangeStatus) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientchangestatus_unpack(v)? +return i, unpacked +} +pub struct CMsgPersonaChangeResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +result u32 +has_result bool +player_name string +has_player_name bool +} +pub fn (o &CMsgPersonaChangeResponse) pack() []byte { +mut res := []byte{} +if o.has_result { +res << vproto.pack_uint32_field(o.result, 1) +} + +if o.has_player_name { +res << vproto.pack_string_field(o.player_name, 2) +} + +return res +} + +pub fn cmsgpersonachangeresponse_unpack(buf []byte) ?CMsgPersonaChangeResponse { +mut res := CMsgPersonaChangeResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_result = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.result = v +i = ii +} + +2 { +res.has_player_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.player_name = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgpersonachangeresponse() CMsgPersonaChangeResponse { +return CMsgPersonaChangeResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgpersonachangeresponse(o CMsgPersonaChangeResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgpersonachangeresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgPersonaChangeResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgpersonachangeresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientPersonaStateFriendClanData { +mut: +unknown_fields []vproto.UnknownField +pub mut: +ogg_app_id u32 +has_ogg_app_id bool +chat_group_id u64 +has_chat_group_id bool +} +pub fn (o &CMsgClientPersonaStateFriendClanData) pack() []byte { +mut res := []byte{} +if o.has_ogg_app_id { +res << vproto.pack_uint32_field(o.ogg_app_id, 1) +} + +if o.has_chat_group_id { +res << vproto.pack_uint64_field(o.chat_group_id, 2) +} + +return res +} + +pub fn cmsgclientpersonastatefriendclandata_unpack(buf []byte) ?CMsgClientPersonaStateFriendClanData { +mut res := CMsgClientPersonaStateFriendClanData{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_ogg_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ogg_app_id = v +i = ii +} + +2 { +res.has_chat_group_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.chat_group_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientpersonastatefriendclandata() CMsgClientPersonaStateFriendClanData { +return CMsgClientPersonaStateFriendClanData{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientpersonastatefriendclandata(o CMsgClientPersonaStateFriendClanData, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientpersonastatefriendclandata(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientPersonaStateFriendClanData) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientpersonastatefriendclandata_unpack(v)? +return i, unpacked +} +pub struct CMsgClientPersonaStateFriendKV { +mut: +unknown_fields []vproto.UnknownField +pub mut: +key string +has_key bool +value string +has_value bool +} +pub fn (o &CMsgClientPersonaStateFriendKV) pack() []byte { +mut res := []byte{} +if o.has_key { +res << vproto.pack_string_field(o.key, 1) +} + +if o.has_value { +res << vproto.pack_string_field(o.value, 2) +} + +return res +} + +pub fn cmsgclientpersonastatefriendkv_unpack(buf []byte) ?CMsgClientPersonaStateFriendKV { +mut res := CMsgClientPersonaStateFriendKV{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_key = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.key = v +i = ii +} + +2 { +res.has_value = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.value = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientpersonastatefriendkv() CMsgClientPersonaStateFriendKV { +return CMsgClientPersonaStateFriendKV{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientpersonastatefriendkv(o CMsgClientPersonaStateFriendKV, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientpersonastatefriendkv(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientPersonaStateFriendKV) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientpersonastatefriendkv_unpack(v)? +return i, unpacked +} +pub struct CMsgClientPersonaStateFriend { +mut: +unknown_fields []vproto.UnknownField +pub mut: +friendid u64 +has_friendid bool +persona_state u32 +has_persona_state bool +game_played_app_id u32 +has_game_played_app_id bool +game_server_ip u32 +has_game_server_ip bool +game_server_port u32 +has_game_server_port bool +persona_state_flags u32 +has_persona_state_flags bool +online_session_instances u32 +has_online_session_instances bool +persona_set_by_user bool +has_persona_set_by_user bool +player_name string +has_player_name bool +query_port u32 +has_query_port bool +steamid_source u64 +has_steamid_source bool +avatar_hash []byte +has_avatar_hash bool +last_logoff u32 +has_last_logoff bool +last_logon u32 +has_last_logon bool +last_seen_online u32 +has_last_seen_online bool +clan_rank u32 +has_clan_rank bool +game_name string +has_game_name bool +gameid u64 +has_gameid bool +game_data_blob []byte +has_game_data_blob bool +clan_data CMsgClientPersonaStateFriendClanData +has_clan_data bool +clan_tag string +has_clan_tag bool +rich_presence []CMsgClientPersonaStateFriendKV +broadcast_id u64 +has_broadcast_id bool +game_lobby_id u64 +has_game_lobby_id bool +watching_broadcast_accountid u32 +has_watching_broadcast_accountid bool +watching_broadcast_appid u32 +has_watching_broadcast_appid bool +watching_broadcast_viewers u32 +has_watching_broadcast_viewers bool +watching_broadcast_title string +has_watching_broadcast_title bool +} +pub fn (o &CMsgClientPersonaStateFriend) pack() []byte { +mut res := []byte{} +if o.has_friendid { +res << vproto.pack_64bit_field(o.friendid, 1) +} + +if o.has_persona_state { +res << vproto.pack_uint32_field(o.persona_state, 2) +} + +if o.has_game_played_app_id { +res << vproto.pack_uint32_field(o.game_played_app_id, 3) +} + +if o.has_game_server_ip { +res << vproto.pack_uint32_field(o.game_server_ip, 4) +} + +if o.has_game_server_port { +res << vproto.pack_uint32_field(o.game_server_port, 5) +} + +if o.has_persona_state_flags { +res << vproto.pack_uint32_field(o.persona_state_flags, 6) +} + +if o.has_online_session_instances { +res << vproto.pack_uint32_field(o.online_session_instances, 7) +} + +if o.has_persona_set_by_user { +res << vproto.pack_bool_field(o.persona_set_by_user, 10) +} + +if o.has_player_name { +res << vproto.pack_string_field(o.player_name, 15) +} + +if o.has_query_port { +res << vproto.pack_uint32_field(o.query_port, 20) +} + +if o.has_steamid_source { +res << vproto.pack_64bit_field(o.steamid_source, 25) +} + +if o.has_avatar_hash { +res << vproto.pack_bytes_field(o.avatar_hash, 31) +} + +if o.has_last_logoff { +res << vproto.pack_uint32_field(o.last_logoff, 45) +} + +if o.has_last_logon { +res << vproto.pack_uint32_field(o.last_logon, 46) +} + +if o.has_last_seen_online { +res << vproto.pack_uint32_field(o.last_seen_online, 47) +} + +if o.has_clan_rank { +res << vproto.pack_uint32_field(o.clan_rank, 50) +} + +if o.has_game_name { +res << vproto.pack_string_field(o.game_name, 55) +} + +if o.has_gameid { +res << vproto.pack_64bit_field(o.gameid, 56) +} + +if o.has_game_data_blob { +res << vproto.pack_bytes_field(o.game_data_blob, 60) +} + +if o.has_clan_data { +res << zzz_vproto_internal_pack_cmsgclientpersonastatefriendclandata(o.clan_data, 64) +} + +if o.has_clan_tag { +res << vproto.pack_string_field(o.clan_tag, 65) +} + +// [packed=false] +for _, x in o.rich_presence { +res << zzz_vproto_internal_pack_cmsgclientpersonastatefriendkv(x, 71) +} + +if o.has_broadcast_id { +res << vproto.pack_64bit_field(o.broadcast_id, 72) +} + +if o.has_game_lobby_id { +res << vproto.pack_64bit_field(o.game_lobby_id, 73) +} + +if o.has_watching_broadcast_accountid { +res << vproto.pack_uint32_field(o.watching_broadcast_accountid, 74) +} + +if o.has_watching_broadcast_appid { +res << vproto.pack_uint32_field(o.watching_broadcast_appid, 75) +} + +if o.has_watching_broadcast_viewers { +res << vproto.pack_uint32_field(o.watching_broadcast_viewers, 76) +} + +if o.has_watching_broadcast_title { +res << vproto.pack_string_field(o.watching_broadcast_title, 77) +} + +return res +} + +pub fn cmsgclientpersonastatefriend_unpack(buf []byte) ?CMsgClientPersonaStateFriend { +mut res := CMsgClientPersonaStateFriend{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_friendid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.friendid = v +i = ii +} + +2 { +res.has_persona_state = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.persona_state = v +i = ii +} + +3 { +res.has_game_played_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.game_played_app_id = v +i = ii +} + +4 { +res.has_game_server_ip = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.game_server_ip = v +i = ii +} + +5 { +res.has_game_server_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.game_server_port = v +i = ii +} + +6 { +res.has_persona_state_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.persona_state_flags = v +i = ii +} + +7 { +res.has_online_session_instances = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.online_session_instances = v +i = ii +} + +10 { +res.has_persona_set_by_user = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.persona_set_by_user = v +i = ii +} + +15 { +res.has_player_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.player_name = v +i = ii +} + +20 { +res.has_query_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.query_port = v +i = ii +} + +25 { +res.has_steamid_source = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_source = v +i = ii +} + +31 { +res.has_avatar_hash = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.avatar_hash = v +i = ii +} + +45 { +res.has_last_logoff = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_logoff = v +i = ii +} + +46 { +res.has_last_logon = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_logon = v +i = ii +} + +47 { +res.has_last_seen_online = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_seen_online = v +i = ii +} + +50 { +res.has_clan_rank = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.clan_rank = v +i = ii +} + +55 { +res.has_game_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.game_name = v +i = ii +} + +56 { +res.has_gameid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.gameid = v +i = ii +} + +60 { +res.has_game_data_blob = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.game_data_blob = v +i = ii +} + +64 { +res.has_clan_data = true +ii, v := zzz_vproto_internal_unpack_cmsgclientpersonastatefriendclandata(cur_buf, tag_wiretype.wire_type)? +res.clan_data = v +i = ii +} + +65 { +res.has_clan_tag = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.clan_tag = v +i = ii +} + +71 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientpersonastatefriendkv(cur_buf, tag_wiretype.wire_type)? +res.rich_presence << v +i = ii +} + +72 { +res.has_broadcast_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.broadcast_id = v +i = ii +} + +73 { +res.has_game_lobby_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.game_lobby_id = v +i = ii +} + +74 { +res.has_watching_broadcast_accountid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.watching_broadcast_accountid = v +i = ii +} + +75 { +res.has_watching_broadcast_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.watching_broadcast_appid = v +i = ii +} + +76 { +res.has_watching_broadcast_viewers = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.watching_broadcast_viewers = v +i = ii +} + +77 { +res.has_watching_broadcast_title = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.watching_broadcast_title = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientpersonastatefriend() CMsgClientPersonaStateFriend { +return CMsgClientPersonaStateFriend{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientpersonastatefriend(o CMsgClientPersonaStateFriend, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientpersonastatefriend(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientPersonaStateFriend) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientpersonastatefriend_unpack(v)? +return i, unpacked +} +pub struct CMsgClientPersonaState { +mut: +unknown_fields []vproto.UnknownField +pub mut: +status_flags u32 +has_status_flags bool +friends []CMsgClientPersonaStateFriend +} +pub fn (o &CMsgClientPersonaState) pack() []byte { +mut res := []byte{} +if o.has_status_flags { +res << vproto.pack_uint32_field(o.status_flags, 1) +} + +// [packed=false] +for _, x in o.friends { +res << zzz_vproto_internal_pack_cmsgclientpersonastatefriend(x, 2) +} + +return res +} + +pub fn cmsgclientpersonastate_unpack(buf []byte) ?CMsgClientPersonaState { +mut res := CMsgClientPersonaState{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_status_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.status_flags = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientpersonastatefriend(cur_buf, tag_wiretype.wire_type)? +res.friends << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientpersonastate() CMsgClientPersonaState { +return CMsgClientPersonaState{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientpersonastate(o CMsgClientPersonaState, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientpersonastate(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientPersonaState) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientpersonastate_unpack(v)? +return i, unpacked +} +pub struct CMsgClientFriendProfileInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid_friend u64 +has_steamid_friend bool +} +pub fn (o &CMsgClientFriendProfileInfo) pack() []byte { +mut res := []byte{} +if o.has_steamid_friend { +res << vproto.pack_64bit_field(o.steamid_friend, 1) +} + +return res +} + +pub fn cmsgclientfriendprofileinfo_unpack(buf []byte) ?CMsgClientFriendProfileInfo { +mut res := CMsgClientFriendProfileInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid_friend = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_friend = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientfriendprofileinfo() CMsgClientFriendProfileInfo { +return CMsgClientFriendProfileInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientfriendprofileinfo(o CMsgClientFriendProfileInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientfriendprofileinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientFriendProfileInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientfriendprofileinfo_unpack(v)? +return i, unpacked +} +pub struct CMsgClientFriendProfileInfoResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +steamid_friend u64 +has_steamid_friend bool +time_created u32 +has_time_created bool +real_name string +has_real_name bool +city_name string +has_city_name bool +state_name string +has_state_name bool +country_name string +has_country_name bool +headline string +has_headline bool +summary string +has_summary bool +} +pub fn (o &CMsgClientFriendProfileInfoResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_steamid_friend { +res << vproto.pack_64bit_field(o.steamid_friend, 2) +} + +if o.has_time_created { +res << vproto.pack_uint32_field(o.time_created, 3) +} + +if o.has_real_name { +res << vproto.pack_string_field(o.real_name, 4) +} + +if o.has_city_name { +res << vproto.pack_string_field(o.city_name, 5) +} + +if o.has_state_name { +res << vproto.pack_string_field(o.state_name, 6) +} + +if o.has_country_name { +res << vproto.pack_string_field(o.country_name, 7) +} + +if o.has_headline { +res << vproto.pack_string_field(o.headline, 8) +} + +if o.has_summary { +res << vproto.pack_string_field(o.summary, 9) +} + +return res +} + +pub fn cmsgclientfriendprofileinforesponse_unpack(buf []byte) ?CMsgClientFriendProfileInfoResponse { +mut res := CMsgClientFriendProfileInfoResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_steamid_friend = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_friend = v +i = ii +} + +3 { +res.has_time_created = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_created = v +i = ii +} + +4 { +res.has_real_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.real_name = v +i = ii +} + +5 { +res.has_city_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.city_name = v +i = ii +} + +6 { +res.has_state_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.state_name = v +i = ii +} + +7 { +res.has_country_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.country_name = v +i = ii +} + +8 { +res.has_headline = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.headline = v +i = ii +} + +9 { +res.has_summary = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.summary = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientfriendprofileinforesponse() CMsgClientFriendProfileInfoResponse { +return CMsgClientFriendProfileInfoResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientfriendprofileinforesponse(o CMsgClientFriendProfileInfoResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientfriendprofileinforesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientFriendProfileInfoResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientfriendprofileinforesponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientCreateFriendsGroup { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +groupname string +has_groupname bool +steamid_friends []u64 +} +pub fn (o &CMsgClientCreateFriendsGroup) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_groupname { +res << vproto.pack_string_field(o.groupname, 2) +} + +// [packed=false] +for _, x in o.steamid_friends { +res << vproto.pack_64bit_field(x, 3) +} + +return res +} + +pub fn cmsgclientcreatefriendsgroup_unpack(buf []byte) ?CMsgClientCreateFriendsGroup { +mut res := CMsgClientCreateFriendsGroup{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_groupname = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.groupname = v +i = ii +} + +3 { +// [packed=false] +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_friends << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientcreatefriendsgroup() CMsgClientCreateFriendsGroup { +return CMsgClientCreateFriendsGroup{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientcreatefriendsgroup(o CMsgClientCreateFriendsGroup, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientcreatefriendsgroup(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientCreateFriendsGroup) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientcreatefriendsgroup_unpack(v)? +return i, unpacked +} +pub struct CMsgClientCreateFriendsGroupResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult u32 +has_eresult bool +groupid int +has_groupid bool +} +pub fn (o &CMsgClientCreateFriendsGroupResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_uint32_field(o.eresult, 1) +} + +if o.has_groupid { +res << vproto.pack_int32_field(o.groupid, 2) +} + +return res +} + +pub fn cmsgclientcreatefriendsgroupresponse_unpack(buf []byte) ?CMsgClientCreateFriendsGroupResponse { +mut res := CMsgClientCreateFriendsGroupResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_groupid = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.groupid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientcreatefriendsgroupresponse() CMsgClientCreateFriendsGroupResponse { +return CMsgClientCreateFriendsGroupResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientcreatefriendsgroupresponse(o CMsgClientCreateFriendsGroupResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientcreatefriendsgroupresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientCreateFriendsGroupResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientcreatefriendsgroupresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientDeleteFriendsGroup { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +groupid int +has_groupid bool +} +pub fn (o &CMsgClientDeleteFriendsGroup) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_groupid { +res << vproto.pack_int32_field(o.groupid, 2) +} + +return res +} + +pub fn cmsgclientdeletefriendsgroup_unpack(buf []byte) ?CMsgClientDeleteFriendsGroup { +mut res := CMsgClientDeleteFriendsGroup{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_groupid = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.groupid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientdeletefriendsgroup() CMsgClientDeleteFriendsGroup { +return CMsgClientDeleteFriendsGroup{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientdeletefriendsgroup(o CMsgClientDeleteFriendsGroup, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientdeletefriendsgroup(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientDeleteFriendsGroup) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientdeletefriendsgroup_unpack(v)? +return i, unpacked +} +pub struct CMsgClientDeleteFriendsGroupResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult u32 +has_eresult bool +} +pub fn (o &CMsgClientDeleteFriendsGroupResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_uint32_field(o.eresult, 1) +} + +return res +} + +pub fn cmsgclientdeletefriendsgroupresponse_unpack(buf []byte) ?CMsgClientDeleteFriendsGroupResponse { +mut res := CMsgClientDeleteFriendsGroupResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientdeletefriendsgroupresponse() CMsgClientDeleteFriendsGroupResponse { +return CMsgClientDeleteFriendsGroupResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientdeletefriendsgroupresponse(o CMsgClientDeleteFriendsGroupResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientdeletefriendsgroupresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientDeleteFriendsGroupResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientdeletefriendsgroupresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientManageFriendsGroup { +mut: +unknown_fields []vproto.UnknownField +pub mut: +groupid int +has_groupid bool +groupname string +has_groupname bool +steamid_friends_added []u64 +steamid_friends_removed []u64 +} +pub fn (o &CMsgClientManageFriendsGroup) pack() []byte { +mut res := []byte{} +if o.has_groupid { +res << vproto.pack_int32_field(o.groupid, 1) +} + +if o.has_groupname { +res << vproto.pack_string_field(o.groupname, 2) +} + +// [packed=false] +for _, x in o.steamid_friends_added { +res << vproto.pack_64bit_field(x, 3) +} + +// [packed=false] +for _, x in o.steamid_friends_removed { +res << vproto.pack_64bit_field(x, 4) +} + +return res +} + +pub fn cmsgclientmanagefriendsgroup_unpack(buf []byte) ?CMsgClientManageFriendsGroup { +mut res := CMsgClientManageFriendsGroup{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_groupid = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.groupid = v +i = ii +} + +2 { +res.has_groupname = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.groupname = v +i = ii +} + +3 { +// [packed=false] +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_friends_added << v +i = ii +} + +4 { +// [packed=false] +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_friends_removed << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmanagefriendsgroup() CMsgClientManageFriendsGroup { +return CMsgClientManageFriendsGroup{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmanagefriendsgroup(o CMsgClientManageFriendsGroup, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmanagefriendsgroup(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientManageFriendsGroup) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmanagefriendsgroup_unpack(v)? +return i, unpacked +} +pub struct CMsgClientManageFriendsGroupResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult u32 +has_eresult bool +} +pub fn (o &CMsgClientManageFriendsGroupResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_uint32_field(o.eresult, 1) +} + +return res +} + +pub fn cmsgclientmanagefriendsgroupresponse_unpack(buf []byte) ?CMsgClientManageFriendsGroupResponse { +mut res := CMsgClientManageFriendsGroupResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmanagefriendsgroupresponse() CMsgClientManageFriendsGroupResponse { +return CMsgClientManageFriendsGroupResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmanagefriendsgroupresponse(o CMsgClientManageFriendsGroupResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmanagefriendsgroupresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientManageFriendsGroupResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmanagefriendsgroupresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientAddFriendToGroup { +mut: +unknown_fields []vproto.UnknownField +pub mut: +groupid int +has_groupid bool +steamiduser u64 +has_steamiduser bool +} +pub fn (o &CMsgClientAddFriendToGroup) pack() []byte { +mut res := []byte{} +if o.has_groupid { +res << vproto.pack_int32_field(o.groupid, 1) +} + +if o.has_steamiduser { +res << vproto.pack_64bit_field(o.steamiduser, 2) +} + +return res +} + +pub fn cmsgclientaddfriendtogroup_unpack(buf []byte) ?CMsgClientAddFriendToGroup { +mut res := CMsgClientAddFriendToGroup{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_groupid = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.groupid = v +i = ii +} + +2 { +res.has_steamiduser = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamiduser = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientaddfriendtogroup() CMsgClientAddFriendToGroup { +return CMsgClientAddFriendToGroup{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientaddfriendtogroup(o CMsgClientAddFriendToGroup, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientaddfriendtogroup(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientAddFriendToGroup) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientaddfriendtogroup_unpack(v)? +return i, unpacked +} +pub struct CMsgClientAddFriendToGroupResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult u32 +has_eresult bool +} +pub fn (o &CMsgClientAddFriendToGroupResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_uint32_field(o.eresult, 1) +} + +return res +} + +pub fn cmsgclientaddfriendtogroupresponse_unpack(buf []byte) ?CMsgClientAddFriendToGroupResponse { +mut res := CMsgClientAddFriendToGroupResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientaddfriendtogroupresponse() CMsgClientAddFriendToGroupResponse { +return CMsgClientAddFriendToGroupResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientaddfriendtogroupresponse(o CMsgClientAddFriendToGroupResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientaddfriendtogroupresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientAddFriendToGroupResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientaddfriendtogroupresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRemoveFriendFromGroup { +mut: +unknown_fields []vproto.UnknownField +pub mut: +groupid int +has_groupid bool +steamiduser u64 +has_steamiduser bool +} +pub fn (o &CMsgClientRemoveFriendFromGroup) pack() []byte { +mut res := []byte{} +if o.has_groupid { +res << vproto.pack_int32_field(o.groupid, 1) +} + +if o.has_steamiduser { +res << vproto.pack_64bit_field(o.steamiduser, 2) +} + +return res +} + +pub fn cmsgclientremovefriendfromgroup_unpack(buf []byte) ?CMsgClientRemoveFriendFromGroup { +mut res := CMsgClientRemoveFriendFromGroup{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_groupid = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.groupid = v +i = ii +} + +2 { +res.has_steamiduser = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamiduser = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientremovefriendfromgroup() CMsgClientRemoveFriendFromGroup { +return CMsgClientRemoveFriendFromGroup{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientremovefriendfromgroup(o CMsgClientRemoveFriendFromGroup, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientremovefriendfromgroup(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRemoveFriendFromGroup) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientremovefriendfromgroup_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRemoveFriendFromGroupResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult u32 +has_eresult bool +} +pub fn (o &CMsgClientRemoveFriendFromGroupResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_uint32_field(o.eresult, 1) +} + +return res +} + +pub fn cmsgclientremovefriendfromgroupresponse_unpack(buf []byte) ?CMsgClientRemoveFriendFromGroupResponse { +mut res := CMsgClientRemoveFriendFromGroupResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientremovefriendfromgroupresponse() CMsgClientRemoveFriendFromGroupResponse { +return CMsgClientRemoveFriendFromGroupResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientremovefriendfromgroupresponse(o CMsgClientRemoveFriendFromGroupResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientremovefriendfromgroupresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRemoveFriendFromGroupResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientremovefriendfromgroupresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientGetEmoticonList { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CMsgClientGetEmoticonList) pack() []byte { +res := []byte{} +return res +} + +pub fn cmsgclientgetemoticonlist_unpack(buf []byte) ?CMsgClientGetEmoticonList { +res := CMsgClientGetEmoticonList{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientgetemoticonlist() CMsgClientGetEmoticonList { +return CMsgClientGetEmoticonList{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientgetemoticonlist(o CMsgClientGetEmoticonList, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientgetemoticonlist(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientGetEmoticonList) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientgetemoticonlist_unpack(v)? +return i, unpacked +} +pub struct CMsgClientEmoticonListEmoticon { +mut: +unknown_fields []vproto.UnknownField +pub mut: +name string +has_name bool +count int +has_count bool +time_last_used u32 +has_time_last_used bool +use_count u32 +has_use_count bool +time_received u32 +has_time_received bool +} +pub fn (o &CMsgClientEmoticonListEmoticon) pack() []byte { +mut res := []byte{} +if o.has_name { +res << vproto.pack_string_field(o.name, 1) +} + +if o.has_count { +res << vproto.pack_int32_field(o.count, 2) +} + +if o.has_time_last_used { +res << vproto.pack_uint32_field(o.time_last_used, 3) +} + +if o.has_use_count { +res << vproto.pack_uint32_field(o.use_count, 4) +} + +if o.has_time_received { +res << vproto.pack_uint32_field(o.time_received, 5) +} + +return res +} + +pub fn cmsgclientemoticonlistemoticon_unpack(buf []byte) ?CMsgClientEmoticonListEmoticon { +mut res := CMsgClientEmoticonListEmoticon{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +2 { +res.has_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.count = v +i = ii +} + +3 { +res.has_time_last_used = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_last_used = v +i = ii +} + +4 { +res.has_use_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.use_count = v +i = ii +} + +5 { +res.has_time_received = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_received = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientemoticonlistemoticon() CMsgClientEmoticonListEmoticon { +return CMsgClientEmoticonListEmoticon{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientemoticonlistemoticon(o CMsgClientEmoticonListEmoticon, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientemoticonlistemoticon(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientEmoticonListEmoticon) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientemoticonlistemoticon_unpack(v)? +return i, unpacked +} +pub struct CMsgClientEmoticonListSticker { +mut: +unknown_fields []vproto.UnknownField +pub mut: +name string +has_name bool +count int +has_count bool +time_received u32 +has_time_received bool +appid u32 +has_appid bool +} +pub fn (o &CMsgClientEmoticonListSticker) pack() []byte { +mut res := []byte{} +if o.has_name { +res << vproto.pack_string_field(o.name, 1) +} + +if o.has_count { +res << vproto.pack_int32_field(o.count, 2) +} + +if o.has_time_received { +res << vproto.pack_uint32_field(o.time_received, 3) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 4) +} + +return res +} + +pub fn cmsgclientemoticonliststicker_unpack(buf []byte) ?CMsgClientEmoticonListSticker { +mut res := CMsgClientEmoticonListSticker{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +2 { +res.has_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.count = v +i = ii +} + +3 { +res.has_time_received = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_received = v +i = ii +} + +4 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientemoticonliststicker() CMsgClientEmoticonListSticker { +return CMsgClientEmoticonListSticker{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientemoticonliststicker(o CMsgClientEmoticonListSticker, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientemoticonliststicker(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientEmoticonListSticker) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientemoticonliststicker_unpack(v)? +return i, unpacked +} +pub struct CMsgClientEmoticonListEffect { +mut: +unknown_fields []vproto.UnknownField +pub mut: +name string +has_name bool +count int +has_count bool +time_received u32 +has_time_received bool +infinite_use bool +has_infinite_use bool +appid u32 +has_appid bool +} +pub fn (o &CMsgClientEmoticonListEffect) pack() []byte { +mut res := []byte{} +if o.has_name { +res << vproto.pack_string_field(o.name, 1) +} + +if o.has_count { +res << vproto.pack_int32_field(o.count, 2) +} + +if o.has_time_received { +res << vproto.pack_uint32_field(o.time_received, 3) +} + +if o.has_infinite_use { +res << vproto.pack_bool_field(o.infinite_use, 4) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 5) +} + +return res +} + +pub fn cmsgclientemoticonlisteffect_unpack(buf []byte) ?CMsgClientEmoticonListEffect { +mut res := CMsgClientEmoticonListEffect{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +2 { +res.has_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.count = v +i = ii +} + +3 { +res.has_time_received = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_received = v +i = ii +} + +4 { +res.has_infinite_use = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.infinite_use = v +i = ii +} + +5 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientemoticonlisteffect() CMsgClientEmoticonListEffect { +return CMsgClientEmoticonListEffect{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientemoticonlisteffect(o CMsgClientEmoticonListEffect, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientemoticonlisteffect(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientEmoticonListEffect) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientemoticonlisteffect_unpack(v)? +return i, unpacked +} +pub struct CMsgClientEmoticonList { +mut: +unknown_fields []vproto.UnknownField +pub mut: +emoticons []CMsgClientEmoticonListEmoticon +stickers []CMsgClientEmoticonListSticker +effects []CMsgClientEmoticonListEffect +} +pub fn (o &CMsgClientEmoticonList) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.emoticons { +res << zzz_vproto_internal_pack_cmsgclientemoticonlistemoticon(x, 1) +} + +// [packed=false] +for _, x in o.stickers { +res << zzz_vproto_internal_pack_cmsgclientemoticonliststicker(x, 2) +} + +// [packed=false] +for _, x in o.effects { +res << zzz_vproto_internal_pack_cmsgclientemoticonlisteffect(x, 3) +} + +return res +} + +pub fn cmsgclientemoticonlist_unpack(buf []byte) ?CMsgClientEmoticonList { +mut res := CMsgClientEmoticonList{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientemoticonlistemoticon(cur_buf, tag_wiretype.wire_type)? +res.emoticons << v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientemoticonliststicker(cur_buf, tag_wiretype.wire_type)? +res.stickers << v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientemoticonlisteffect(cur_buf, tag_wiretype.wire_type)? +res.effects << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientemoticonlist() CMsgClientEmoticonList { +return CMsgClientEmoticonList{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientemoticonlist(o CMsgClientEmoticonList, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientemoticonlist(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientEmoticonList) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientemoticonlist_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_clientserver_login_pb.v b/proto/steammessages_clientserver_login_pb.v new file mode 100644 index 0000000..8f07c1b --- /dev/null +++ b/proto/steammessages_clientserver_login_pb.v @@ -0,0 +1,2039 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CMsgClientHeartBeat { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CMsgClientHeartBeat) pack() []byte { +res := []byte{} +return res +} + +pub fn cmsgclientheartbeat_unpack(buf []byte) ?CMsgClientHeartBeat { +res := CMsgClientHeartBeat{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientheartbeat() CMsgClientHeartBeat { +return CMsgClientHeartBeat{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientheartbeat(o CMsgClientHeartBeat, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientheartbeat(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientHeartBeat) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientheartbeat_unpack(v)? +return i, unpacked +} +pub struct CMsgClientServerTimestampRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +client_request_timestamp u64 +has_client_request_timestamp bool +} +pub fn (o &CMsgClientServerTimestampRequest) pack() []byte { +mut res := []byte{} +if o.has_client_request_timestamp { +res << vproto.pack_uint64_field(o.client_request_timestamp, 1) +} + +return res +} + +pub fn cmsgclientservertimestamprequest_unpack(buf []byte) ?CMsgClientServerTimestampRequest { +mut res := CMsgClientServerTimestampRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_client_request_timestamp = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.client_request_timestamp = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientservertimestamprequest() CMsgClientServerTimestampRequest { +return CMsgClientServerTimestampRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientservertimestamprequest(o CMsgClientServerTimestampRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientservertimestamprequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientServerTimestampRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientservertimestamprequest_unpack(v)? +return i, unpacked +} +pub struct CMsgClientServerTimestampResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +client_request_timestamp u64 +has_client_request_timestamp bool +server_timestamp_ms u64 +has_server_timestamp_ms bool +} +pub fn (o &CMsgClientServerTimestampResponse) pack() []byte { +mut res := []byte{} +if o.has_client_request_timestamp { +res << vproto.pack_uint64_field(o.client_request_timestamp, 1) +} + +if o.has_server_timestamp_ms { +res << vproto.pack_uint64_field(o.server_timestamp_ms, 2) +} + +return res +} + +pub fn cmsgclientservertimestampresponse_unpack(buf []byte) ?CMsgClientServerTimestampResponse { +mut res := CMsgClientServerTimestampResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_client_request_timestamp = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.client_request_timestamp = v +i = ii +} + +2 { +res.has_server_timestamp_ms = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.server_timestamp_ms = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientservertimestampresponse() CMsgClientServerTimestampResponse { +return CMsgClientServerTimestampResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientservertimestampresponse(o CMsgClientServerTimestampResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientservertimestampresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientServerTimestampResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientservertimestampresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientSecret { +mut: +unknown_fields []vproto.UnknownField +pub mut: +version u32 +has_version bool +appid u32 +has_appid bool +deviceid u32 +has_deviceid bool +nonce u64 +has_nonce bool +hmac []byte +has_hmac bool +} +pub fn (o &CMsgClientSecret) pack() []byte { +mut res := []byte{} +if o.has_version { +res << vproto.pack_uint32_field(o.version, 1) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 2) +} + +if o.has_deviceid { +res << vproto.pack_uint32_field(o.deviceid, 3) +} + +if o.has_nonce { +res << vproto.pack_64bit_field(o.nonce, 4) +} + +if o.has_hmac { +res << vproto.pack_bytes_field(o.hmac, 5) +} + +return res +} + +pub fn cmsgclientsecret_unpack(buf []byte) ?CMsgClientSecret { +mut res := CMsgClientSecret{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_version = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.version = v +i = ii +} + +2 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +3 { +res.has_deviceid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.deviceid = v +i = ii +} + +4 { +res.has_nonce = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.nonce = v +i = ii +} + +5 { +res.has_hmac = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.hmac = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientsecret() CMsgClientSecret { +return CMsgClientSecret{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientsecret(o CMsgClientSecret, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientsecret(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientSecret) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientsecret_unpack(v)? +return i, unpacked +} +pub struct CMsgClientLogon { +mut: +unknown_fields []vproto.UnknownField +pub mut: +protocol_version u32 +has_protocol_version bool +deprecated_obfustucated_private_ip u32 +has_deprecated_obfustucated_private_ip bool +cell_id u32 +has_cell_id bool +last_session_id u32 +has_last_session_id bool +client_package_version u32 +has_client_package_version bool +client_language string +has_client_language bool +client_os_type u32 +has_client_os_type bool +should_remember_password bool +has_should_remember_password bool +wine_version string +has_wine_version bool +deprecated_10 u32 +has_deprecated_10 bool +obfuscated_private_ip CMsgIPaddress +has_obfuscated_private_ip bool +deprecated_public_ip u32 +has_deprecated_public_ip bool +qos_level u32 +has_qos_level bool +client_supplied_steam_id u64 +has_client_supplied_steam_id bool +public_ip CMsgIPaddress +has_public_ip bool +machine_id []byte +has_machine_id bool +launcher_type u32 +has_launcher_type bool +ui_mode u32 +has_ui_mode bool +chat_mode u32 +has_chat_mode bool +steam2_auth_ticket []byte +has_steam2_auth_ticket bool +email_address string +has_email_address bool +rtime32_account_creation u32 +has_rtime32_account_creation bool +account_name string +has_account_name bool +password string +has_password bool +game_server_token string +has_game_server_token bool +login_key string +has_login_key bool +was_converted_deprecated_msg bool +has_was_converted_deprecated_msg bool +anon_user_target_account_name string +has_anon_user_target_account_name bool +resolved_user_steam_id u64 +has_resolved_user_steam_id bool +eresult_sentryfile int +has_eresult_sentryfile bool +sha_sentryfile []byte +has_sha_sentryfile bool +auth_code string +has_auth_code bool +otp_type int +has_otp_type bool +otp_value u32 +has_otp_value bool +otp_identifier string +has_otp_identifier bool +steam2_ticket_request bool +has_steam2_ticket_request bool +sony_psn_ticket []byte +has_sony_psn_ticket bool +sony_psn_service_id string +has_sony_psn_service_id bool +create_new_psn_linked_account_if_needed bool +has_create_new_psn_linked_account_if_needed bool +sony_psn_name string +has_sony_psn_name bool +game_server_app_id int +has_game_server_app_id bool +steamguard_dont_remember_computer bool +has_steamguard_dont_remember_computer bool +machine_name string +has_machine_name bool +machine_name_userchosen string +has_machine_name_userchosen bool +country_override string +has_country_override bool +is_steam_box bool +has_is_steam_box bool +client_instance_id u64 +has_client_instance_id bool +two_factor_code string +has_two_factor_code bool +supports_rate_limit_response bool +has_supports_rate_limit_response bool +web_logon_nonce string +has_web_logon_nonce bool +priority_reason int +has_priority_reason bool +embedded_client_secret CMsgClientSecret +has_embedded_client_secret bool +disable_partner_autogrants bool +has_disable_partner_autogrants bool +} +pub fn (o &CMsgClientLogon) pack() []byte { +mut res := []byte{} +if o.has_protocol_version { +res << vproto.pack_uint32_field(o.protocol_version, 1) +} + +if o.has_deprecated_obfustucated_private_ip { +res << vproto.pack_uint32_field(o.deprecated_obfustucated_private_ip, 2) +} + +if o.has_cell_id { +res << vproto.pack_uint32_field(o.cell_id, 3) +} + +if o.has_last_session_id { +res << vproto.pack_uint32_field(o.last_session_id, 4) +} + +if o.has_client_package_version { +res << vproto.pack_uint32_field(o.client_package_version, 5) +} + +if o.has_client_language { +res << vproto.pack_string_field(o.client_language, 6) +} + +if o.has_client_os_type { +res << vproto.pack_uint32_field(o.client_os_type, 7) +} + +if o.has_should_remember_password { +res << vproto.pack_bool_field(o.should_remember_password, 8) +} + +if o.has_wine_version { +res << vproto.pack_string_field(o.wine_version, 9) +} + +if o.has_deprecated_10 { +res << vproto.pack_uint32_field(o.deprecated_10, 10) +} + +if o.has_obfuscated_private_ip { +res << zzz_vproto_internal_pack_cmsgipaddress(o.obfuscated_private_ip, 11) +} + +if o.has_deprecated_public_ip { +res << vproto.pack_uint32_field(o.deprecated_public_ip, 20) +} + +if o.has_qos_level { +res << vproto.pack_uint32_field(o.qos_level, 21) +} + +if o.has_client_supplied_steam_id { +res << vproto.pack_64bit_field(o.client_supplied_steam_id, 22) +} + +if o.has_public_ip { +res << zzz_vproto_internal_pack_cmsgipaddress(o.public_ip, 23) +} + +if o.has_machine_id { +res << vproto.pack_bytes_field(o.machine_id, 30) +} + +if o.has_launcher_type { +res << vproto.pack_uint32_field(o.launcher_type, 31) +} + +if o.has_ui_mode { +res << vproto.pack_uint32_field(o.ui_mode, 32) +} + +if o.has_chat_mode { +res << vproto.pack_uint32_field(o.chat_mode, 33) +} + +if o.has_steam2_auth_ticket { +res << vproto.pack_bytes_field(o.steam2_auth_ticket, 41) +} + +if o.has_email_address { +res << vproto.pack_string_field(o.email_address, 42) +} + +if o.has_rtime32_account_creation { +res << vproto.pack_32bit_field(o.rtime32_account_creation, 43) +} + +if o.has_account_name { +res << vproto.pack_string_field(o.account_name, 50) +} + +if o.has_password { +res << vproto.pack_string_field(o.password, 51) +} + +if o.has_game_server_token { +res << vproto.pack_string_field(o.game_server_token, 52) +} + +if o.has_login_key { +res << vproto.pack_string_field(o.login_key, 60) +} + +if o.has_was_converted_deprecated_msg { +res << vproto.pack_bool_field(o.was_converted_deprecated_msg, 70) +} + +if o.has_anon_user_target_account_name { +res << vproto.pack_string_field(o.anon_user_target_account_name, 80) +} + +if o.has_resolved_user_steam_id { +res << vproto.pack_64bit_field(o.resolved_user_steam_id, 81) +} + +if o.has_eresult_sentryfile { +res << vproto.pack_int32_field(o.eresult_sentryfile, 82) +} + +if o.has_sha_sentryfile { +res << vproto.pack_bytes_field(o.sha_sentryfile, 83) +} + +if o.has_auth_code { +res << vproto.pack_string_field(o.auth_code, 84) +} + +if o.has_otp_type { +res << vproto.pack_int32_field(o.otp_type, 85) +} + +if o.has_otp_value { +res << vproto.pack_uint32_field(o.otp_value, 86) +} + +if o.has_otp_identifier { +res << vproto.pack_string_field(o.otp_identifier, 87) +} + +if o.has_steam2_ticket_request { +res << vproto.pack_bool_field(o.steam2_ticket_request, 88) +} + +if o.has_sony_psn_ticket { +res << vproto.pack_bytes_field(o.sony_psn_ticket, 90) +} + +if o.has_sony_psn_service_id { +res << vproto.pack_string_field(o.sony_psn_service_id, 91) +} + +if o.has_create_new_psn_linked_account_if_needed { +res << vproto.pack_bool_field(o.create_new_psn_linked_account_if_needed, 92) +} + +if o.has_sony_psn_name { +res << vproto.pack_string_field(o.sony_psn_name, 93) +} + +if o.has_game_server_app_id { +res << vproto.pack_int32_field(o.game_server_app_id, 94) +} + +if o.has_steamguard_dont_remember_computer { +res << vproto.pack_bool_field(o.steamguard_dont_remember_computer, 95) +} + +if o.has_machine_name { +res << vproto.pack_string_field(o.machine_name, 96) +} + +if o.has_machine_name_userchosen { +res << vproto.pack_string_field(o.machine_name_userchosen, 97) +} + +if o.has_country_override { +res << vproto.pack_string_field(o.country_override, 98) +} + +if o.has_is_steam_box { +res << vproto.pack_bool_field(o.is_steam_box, 99) +} + +if o.has_client_instance_id { +res << vproto.pack_uint64_field(o.client_instance_id, 100) +} + +if o.has_two_factor_code { +res << vproto.pack_string_field(o.two_factor_code, 101) +} + +if o.has_supports_rate_limit_response { +res << vproto.pack_bool_field(o.supports_rate_limit_response, 102) +} + +if o.has_web_logon_nonce { +res << vproto.pack_string_field(o.web_logon_nonce, 103) +} + +if o.has_priority_reason { +res << vproto.pack_int32_field(o.priority_reason, 104) +} + +if o.has_embedded_client_secret { +res << zzz_vproto_internal_pack_cmsgclientsecret(o.embedded_client_secret, 105) +} + +if o.has_disable_partner_autogrants { +res << vproto.pack_bool_field(o.disable_partner_autogrants, 106) +} + +return res +} + +pub fn cmsgclientlogon_unpack(buf []byte) ?CMsgClientLogon { +mut res := CMsgClientLogon{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_protocol_version = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.protocol_version = v +i = ii +} + +2 { +res.has_deprecated_obfustucated_private_ip = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated_obfustucated_private_ip = v +i = ii +} + +3 { +res.has_cell_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cell_id = v +i = ii +} + +4 { +res.has_last_session_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_session_id = v +i = ii +} + +5 { +res.has_client_package_version = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.client_package_version = v +i = ii +} + +6 { +res.has_client_language = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.client_language = v +i = ii +} + +7 { +res.has_client_os_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.client_os_type = v +i = ii +} + +8 { +res.has_should_remember_password = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.should_remember_password = v +i = ii +} + +9 { +res.has_wine_version = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.wine_version = v +i = ii +} + +10 { +res.has_deprecated_10 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated_10 = v +i = ii +} + +11 { +res.has_obfuscated_private_ip = true +ii, v := zzz_vproto_internal_unpack_cmsgipaddress(cur_buf, tag_wiretype.wire_type)? +res.obfuscated_private_ip = v +i = ii +} + +20 { +res.has_deprecated_public_ip = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated_public_ip = v +i = ii +} + +21 { +res.has_qos_level = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.qos_level = v +i = ii +} + +22 { +res.has_client_supplied_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.client_supplied_steam_id = v +i = ii +} + +23 { +res.has_public_ip = true +ii, v := zzz_vproto_internal_unpack_cmsgipaddress(cur_buf, tag_wiretype.wire_type)? +res.public_ip = v +i = ii +} + +30 { +res.has_machine_id = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.machine_id = v +i = ii +} + +31 { +res.has_launcher_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.launcher_type = v +i = ii +} + +32 { +res.has_ui_mode = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ui_mode = v +i = ii +} + +33 { +res.has_chat_mode = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.chat_mode = v +i = ii +} + +41 { +res.has_steam2_auth_ticket = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.steam2_auth_ticket = v +i = ii +} + +42 { +res.has_email_address = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.email_address = v +i = ii +} + +43 { +res.has_rtime32_account_creation = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.rtime32_account_creation = v +i = ii +} + +50 { +res.has_account_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.account_name = v +i = ii +} + +51 { +res.has_password = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.password = v +i = ii +} + +52 { +res.has_game_server_token = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.game_server_token = v +i = ii +} + +60 { +res.has_login_key = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.login_key = v +i = ii +} + +70 { +res.has_was_converted_deprecated_msg = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.was_converted_deprecated_msg = v +i = ii +} + +80 { +res.has_anon_user_target_account_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.anon_user_target_account_name = v +i = ii +} + +81 { +res.has_resolved_user_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.resolved_user_steam_id = v +i = ii +} + +82 { +res.has_eresult_sentryfile = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult_sentryfile = v +i = ii +} + +83 { +res.has_sha_sentryfile = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha_sentryfile = v +i = ii +} + +84 { +res.has_auth_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.auth_code = v +i = ii +} + +85 { +res.has_otp_type = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.otp_type = v +i = ii +} + +86 { +res.has_otp_value = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.otp_value = v +i = ii +} + +87 { +res.has_otp_identifier = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.otp_identifier = v +i = ii +} + +88 { +res.has_steam2_ticket_request = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.steam2_ticket_request = v +i = ii +} + +90 { +res.has_sony_psn_ticket = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sony_psn_ticket = v +i = ii +} + +91 { +res.has_sony_psn_service_id = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.sony_psn_service_id = v +i = ii +} + +92 { +res.has_create_new_psn_linked_account_if_needed = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.create_new_psn_linked_account_if_needed = v +i = ii +} + +93 { +res.has_sony_psn_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.sony_psn_name = v +i = ii +} + +94 { +res.has_game_server_app_id = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.game_server_app_id = v +i = ii +} + +95 { +res.has_steamguard_dont_remember_computer = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.steamguard_dont_remember_computer = v +i = ii +} + +96 { +res.has_machine_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.machine_name = v +i = ii +} + +97 { +res.has_machine_name_userchosen = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.machine_name_userchosen = v +i = ii +} + +98 { +res.has_country_override = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.country_override = v +i = ii +} + +99 { +res.has_is_steam_box = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_steam_box = v +i = ii +} + +100 { +res.has_client_instance_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.client_instance_id = v +i = ii +} + +101 { +res.has_two_factor_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.two_factor_code = v +i = ii +} + +102 { +res.has_supports_rate_limit_response = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.supports_rate_limit_response = v +i = ii +} + +103 { +res.has_web_logon_nonce = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.web_logon_nonce = v +i = ii +} + +104 { +res.has_priority_reason = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.priority_reason = v +i = ii +} + +105 { +res.has_embedded_client_secret = true +ii, v := zzz_vproto_internal_unpack_cmsgclientsecret(cur_buf, tag_wiretype.wire_type)? +res.embedded_client_secret = v +i = ii +} + +106 { +res.has_disable_partner_autogrants = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.disable_partner_autogrants = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientlogon() CMsgClientLogon { +return CMsgClientLogon{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientlogon(o CMsgClientLogon, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientlogon(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientLogon) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientlogon_unpack(v)? +return i, unpacked +} +pub struct CMsgClientLogonResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +out_of_game_heartbeat_seconds int +has_out_of_game_heartbeat_seconds bool +in_game_heartbeat_seconds int +has_in_game_heartbeat_seconds bool +deprecated_public_ip u32 +has_deprecated_public_ip bool +rtime32_server_time u32 +has_rtime32_server_time bool +account_flags u32 +has_account_flags bool +cell_id u32 +has_cell_id bool +email_domain string +has_email_domain bool +steam2_ticket []byte +has_steam2_ticket bool +eresult_extended int +has_eresult_extended bool +webapi_authenticate_user_nonce string +has_webapi_authenticate_user_nonce bool +cell_id_ping_threshold u32 +has_cell_id_ping_threshold bool +deprecated_use_pics bool +has_deprecated_use_pics bool +vanity_url string +has_vanity_url bool +public_ip CMsgIPaddress +has_public_ip bool +client_supplied_steamid u64 +has_client_supplied_steamid bool +ip_country_code string +has_ip_country_code bool +parental_settings []byte +has_parental_settings bool +parental_setting_signature []byte +has_parental_setting_signature bool +count_loginfailures_to_migrate int +has_count_loginfailures_to_migrate bool +count_disconnects_to_migrate int +has_count_disconnects_to_migrate bool +ogs_data_report_time_window int +has_ogs_data_report_time_window bool +client_instance_id u64 +has_client_instance_id bool +force_client_update_check bool +has_force_client_update_check bool +} +pub fn (o &CMsgClientLogonResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_out_of_game_heartbeat_seconds { +res << vproto.pack_int32_field(o.out_of_game_heartbeat_seconds, 2) +} + +if o.has_in_game_heartbeat_seconds { +res << vproto.pack_int32_field(o.in_game_heartbeat_seconds, 3) +} + +if o.has_deprecated_public_ip { +res << vproto.pack_uint32_field(o.deprecated_public_ip, 4) +} + +if o.has_rtime32_server_time { +res << vproto.pack_32bit_field(o.rtime32_server_time, 5) +} + +if o.has_account_flags { +res << vproto.pack_uint32_field(o.account_flags, 6) +} + +if o.has_cell_id { +res << vproto.pack_uint32_field(o.cell_id, 7) +} + +if o.has_email_domain { +res << vproto.pack_string_field(o.email_domain, 8) +} + +if o.has_steam2_ticket { +res << vproto.pack_bytes_field(o.steam2_ticket, 9) +} + +if o.has_eresult_extended { +res << vproto.pack_int32_field(o.eresult_extended, 10) +} + +if o.has_webapi_authenticate_user_nonce { +res << vproto.pack_string_field(o.webapi_authenticate_user_nonce, 11) +} + +if o.has_cell_id_ping_threshold { +res << vproto.pack_uint32_field(o.cell_id_ping_threshold, 12) +} + +if o.has_deprecated_use_pics { +res << vproto.pack_bool_field(o.deprecated_use_pics, 13) +} + +if o.has_vanity_url { +res << vproto.pack_string_field(o.vanity_url, 14) +} + +if o.has_public_ip { +res << zzz_vproto_internal_pack_cmsgipaddress(o.public_ip, 15) +} + +if o.has_client_supplied_steamid { +res << vproto.pack_64bit_field(o.client_supplied_steamid, 20) +} + +if o.has_ip_country_code { +res << vproto.pack_string_field(o.ip_country_code, 21) +} + +if o.has_parental_settings { +res << vproto.pack_bytes_field(o.parental_settings, 22) +} + +if o.has_parental_setting_signature { +res << vproto.pack_bytes_field(o.parental_setting_signature, 23) +} + +if o.has_count_loginfailures_to_migrate { +res << vproto.pack_int32_field(o.count_loginfailures_to_migrate, 24) +} + +if o.has_count_disconnects_to_migrate { +res << vproto.pack_int32_field(o.count_disconnects_to_migrate, 25) +} + +if o.has_ogs_data_report_time_window { +res << vproto.pack_int32_field(o.ogs_data_report_time_window, 26) +} + +if o.has_client_instance_id { +res << vproto.pack_uint64_field(o.client_instance_id, 27) +} + +if o.has_force_client_update_check { +res << vproto.pack_bool_field(o.force_client_update_check, 28) +} + +return res +} + +pub fn cmsgclientlogonresponse_unpack(buf []byte) ?CMsgClientLogonResponse { +mut res := CMsgClientLogonResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_out_of_game_heartbeat_seconds = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.out_of_game_heartbeat_seconds = v +i = ii +} + +3 { +res.has_in_game_heartbeat_seconds = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.in_game_heartbeat_seconds = v +i = ii +} + +4 { +res.has_deprecated_public_ip = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated_public_ip = v +i = ii +} + +5 { +res.has_rtime32_server_time = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.rtime32_server_time = v +i = ii +} + +6 { +res.has_account_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.account_flags = v +i = ii +} + +7 { +res.has_cell_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cell_id = v +i = ii +} + +8 { +res.has_email_domain = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.email_domain = v +i = ii +} + +9 { +res.has_steam2_ticket = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.steam2_ticket = v +i = ii +} + +10 { +res.has_eresult_extended = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult_extended = v +i = ii +} + +11 { +res.has_webapi_authenticate_user_nonce = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.webapi_authenticate_user_nonce = v +i = ii +} + +12 { +res.has_cell_id_ping_threshold = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cell_id_ping_threshold = v +i = ii +} + +13 { +res.has_deprecated_use_pics = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated_use_pics = v +i = ii +} + +14 { +res.has_vanity_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.vanity_url = v +i = ii +} + +15 { +res.has_public_ip = true +ii, v := zzz_vproto_internal_unpack_cmsgipaddress(cur_buf, tag_wiretype.wire_type)? +res.public_ip = v +i = ii +} + +20 { +res.has_client_supplied_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.client_supplied_steamid = v +i = ii +} + +21 { +res.has_ip_country_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.ip_country_code = v +i = ii +} + +22 { +res.has_parental_settings = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.parental_settings = v +i = ii +} + +23 { +res.has_parental_setting_signature = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.parental_setting_signature = v +i = ii +} + +24 { +res.has_count_loginfailures_to_migrate = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.count_loginfailures_to_migrate = v +i = ii +} + +25 { +res.has_count_disconnects_to_migrate = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.count_disconnects_to_migrate = v +i = ii +} + +26 { +res.has_ogs_data_report_time_window = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.ogs_data_report_time_window = v +i = ii +} + +27 { +res.has_client_instance_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.client_instance_id = v +i = ii +} + +28 { +res.has_force_client_update_check = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.force_client_update_check = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientlogonresponse() CMsgClientLogonResponse { +return CMsgClientLogonResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientlogonresponse(o CMsgClientLogonResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientlogonresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientLogonResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientlogonresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRequestWebAPiauthenticateUserNonce { +mut: +unknown_fields []vproto.UnknownField +pub mut: +token_type int +has_token_type bool +} +pub fn (o &CMsgClientRequestWebAPiauthenticateUserNonce) pack() []byte { +mut res := []byte{} +if o.has_token_type { +res << vproto.pack_int32_field(o.token_type, 1) +} + +return res +} + +pub fn cmsgclientrequestwebapiauthenticateusernonce_unpack(buf []byte) ?CMsgClientRequestWebAPiauthenticateUserNonce { +mut res := CMsgClientRequestWebAPiauthenticateUserNonce{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_token_type = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.token_type = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientrequestwebapiauthenticateusernonce() CMsgClientRequestWebAPiauthenticateUserNonce { +return CMsgClientRequestWebAPiauthenticateUserNonce{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientrequestwebapiauthenticateusernonce(o CMsgClientRequestWebAPiauthenticateUserNonce, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientrequestwebapiauthenticateusernonce(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRequestWebAPiauthenticateUserNonce) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientrequestwebapiauthenticateusernonce_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRequestWebAPiauthenticateUserNonceResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +webapi_authenticate_user_nonce string +has_webapi_authenticate_user_nonce bool +token_type int +has_token_type bool +} +pub fn (o &CMsgClientRequestWebAPiauthenticateUserNonceResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_webapi_authenticate_user_nonce { +res << vproto.pack_string_field(o.webapi_authenticate_user_nonce, 11) +} + +if o.has_token_type { +res << vproto.pack_int32_field(o.token_type, 3) +} + +return res +} + +pub fn cmsgclientrequestwebapiauthenticateusernonceresponse_unpack(buf []byte) ?CMsgClientRequestWebAPiauthenticateUserNonceResponse { +mut res := CMsgClientRequestWebAPiauthenticateUserNonceResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +11 { +res.has_webapi_authenticate_user_nonce = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.webapi_authenticate_user_nonce = v +i = ii +} + +3 { +res.has_token_type = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.token_type = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientrequestwebapiauthenticateusernonceresponse() CMsgClientRequestWebAPiauthenticateUserNonceResponse { +return CMsgClientRequestWebAPiauthenticateUserNonceResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientrequestwebapiauthenticateusernonceresponse(o CMsgClientRequestWebAPiauthenticateUserNonceResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientrequestwebapiauthenticateusernonceresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRequestWebAPiauthenticateUserNonceResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientrequestwebapiauthenticateusernonceresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientLogOff { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CMsgClientLogOff) pack() []byte { +res := []byte{} +return res +} + +pub fn cmsgclientlogoff_unpack(buf []byte) ?CMsgClientLogOff { +res := CMsgClientLogOff{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientlogoff() CMsgClientLogOff { +return CMsgClientLogOff{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientlogoff(o CMsgClientLogOff, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientlogoff(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientLogOff) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientlogoff_unpack(v)? +return i, unpacked +} +pub struct CMsgClientLoggedOff { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +} +pub fn (o &CMsgClientLoggedOff) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +return res +} + +pub fn cmsgclientloggedoff_unpack(buf []byte) ?CMsgClientLoggedOff { +mut res := CMsgClientLoggedOff{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientloggedoff() CMsgClientLoggedOff { +return CMsgClientLoggedOff{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientloggedoff(o CMsgClientLoggedOff, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientloggedoff(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientLoggedOff) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientloggedoff_unpack(v)? +return i, unpacked +} +pub struct CMsgClientNewLoginKey { +mut: +unknown_fields []vproto.UnknownField +pub mut: +unique_id u32 +has_unique_id bool +login_key string +has_login_key bool +} +pub fn (o &CMsgClientNewLoginKey) pack() []byte { +mut res := []byte{} +if o.has_unique_id { +res << vproto.pack_uint32_field(o.unique_id, 1) +} + +if o.has_login_key { +res << vproto.pack_string_field(o.login_key, 2) +} + +return res +} + +pub fn cmsgclientnewloginkey_unpack(buf []byte) ?CMsgClientNewLoginKey { +mut res := CMsgClientNewLoginKey{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_unique_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.unique_id = v +i = ii +} + +2 { +res.has_login_key = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.login_key = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientnewloginkey() CMsgClientNewLoginKey { +return CMsgClientNewLoginKey{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientnewloginkey(o CMsgClientNewLoginKey, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientnewloginkey(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientNewLoginKey) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientnewloginkey_unpack(v)? +return i, unpacked +} +pub struct CMsgClientNewLoginKeyAccepted { +mut: +unknown_fields []vproto.UnknownField +pub mut: +unique_id u32 +has_unique_id bool +} +pub fn (o &CMsgClientNewLoginKeyAccepted) pack() []byte { +mut res := []byte{} +if o.has_unique_id { +res << vproto.pack_uint32_field(o.unique_id, 1) +} + +return res +} + +pub fn cmsgclientnewloginkeyaccepted_unpack(buf []byte) ?CMsgClientNewLoginKeyAccepted { +mut res := CMsgClientNewLoginKeyAccepted{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_unique_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.unique_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientnewloginkeyaccepted() CMsgClientNewLoginKeyAccepted { +return CMsgClientNewLoginKeyAccepted{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientnewloginkeyaccepted(o CMsgClientNewLoginKeyAccepted, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientnewloginkeyaccepted(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientNewLoginKeyAccepted) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientnewloginkeyaccepted_unpack(v)? +return i, unpacked +} +pub struct CMsgClientAccountInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +persona_name string +has_persona_name bool +ip_country string +has_ip_country bool +count_authed_computers int +has_count_authed_computers bool +account_flags u32 +has_account_flags bool +facebook_id u64 +has_facebook_id bool +facebook_name string +has_facebook_name bool +steamguard_notify_newmachines bool +has_steamguard_notify_newmachines bool +steamguard_machine_name_user_chosen string +has_steamguard_machine_name_user_chosen bool +is_phone_verified bool +has_is_phone_verified bool +two_factor_state u32 +has_two_factor_state bool +is_phone_identifying bool +has_is_phone_identifying bool +is_phone_needing_reverify bool +has_is_phone_needing_reverify bool +} +pub fn (o &CMsgClientAccountInfo) pack() []byte { +mut res := []byte{} +if o.has_persona_name { +res << vproto.pack_string_field(o.persona_name, 1) +} + +if o.has_ip_country { +res << vproto.pack_string_field(o.ip_country, 2) +} + +if o.has_count_authed_computers { +res << vproto.pack_int32_field(o.count_authed_computers, 5) +} + +if o.has_account_flags { +res << vproto.pack_uint32_field(o.account_flags, 7) +} + +if o.has_facebook_id { +res << vproto.pack_uint64_field(o.facebook_id, 8) +} + +if o.has_facebook_name { +res << vproto.pack_string_field(o.facebook_name, 9) +} + +if o.has_steamguard_notify_newmachines { +res << vproto.pack_bool_field(o.steamguard_notify_newmachines, 14) +} + +if o.has_steamguard_machine_name_user_chosen { +res << vproto.pack_string_field(o.steamguard_machine_name_user_chosen, 15) +} + +if o.has_is_phone_verified { +res << vproto.pack_bool_field(o.is_phone_verified, 16) +} + +if o.has_two_factor_state { +res << vproto.pack_uint32_field(o.two_factor_state, 17) +} + +if o.has_is_phone_identifying { +res << vproto.pack_bool_field(o.is_phone_identifying, 18) +} + +if o.has_is_phone_needing_reverify { +res << vproto.pack_bool_field(o.is_phone_needing_reverify, 19) +} + +return res +} + +pub fn cmsgclientaccountinfo_unpack(buf []byte) ?CMsgClientAccountInfo { +mut res := CMsgClientAccountInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_persona_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.persona_name = v +i = ii +} + +2 { +res.has_ip_country = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.ip_country = v +i = ii +} + +5 { +res.has_count_authed_computers = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.count_authed_computers = v +i = ii +} + +7 { +res.has_account_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.account_flags = v +i = ii +} + +8 { +res.has_facebook_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.facebook_id = v +i = ii +} + +9 { +res.has_facebook_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.facebook_name = v +i = ii +} + +14 { +res.has_steamguard_notify_newmachines = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.steamguard_notify_newmachines = v +i = ii +} + +15 { +res.has_steamguard_machine_name_user_chosen = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.steamguard_machine_name_user_chosen = v +i = ii +} + +16 { +res.has_is_phone_verified = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_phone_verified = v +i = ii +} + +17 { +res.has_two_factor_state = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.two_factor_state = v +i = ii +} + +18 { +res.has_is_phone_identifying = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_phone_identifying = v +i = ii +} + +19 { +res.has_is_phone_needing_reverify = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_phone_needing_reverify = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientaccountinfo() CMsgClientAccountInfo { +return CMsgClientAccountInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientaccountinfo(o CMsgClientAccountInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientaccountinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientAccountInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientaccountinfo_unpack(v)? +return i, unpacked +} +pub struct CMsgClientChallengeRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +} +pub fn (o &CMsgClientChallengeRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +return res +} + +pub fn cmsgclientchallengerequest_unpack(buf []byte) ?CMsgClientChallengeRequest { +mut res := CMsgClientChallengeRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientchallengerequest() CMsgClientChallengeRequest { +return CMsgClientChallengeRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientchallengerequest(o CMsgClientChallengeRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientchallengerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientChallengeRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientchallengerequest_unpack(v)? +return i, unpacked +} +pub struct CMsgClientChallengeResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +challenge u64 +has_challenge bool +} +pub fn (o &CMsgClientChallengeResponse) pack() []byte { +mut res := []byte{} +if o.has_challenge { +res << vproto.pack_64bit_field(o.challenge, 1) +} + +return res +} + +pub fn cmsgclientchallengeresponse_unpack(buf []byte) ?CMsgClientChallengeResponse { +mut res := CMsgClientChallengeResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_challenge = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.challenge = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientchallengeresponse() CMsgClientChallengeResponse { +return CMsgClientChallengeResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientchallengeresponse(o CMsgClientChallengeResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientchallengeresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientChallengeResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientchallengeresponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_clientserver_pb.v b/proto/steammessages_clientserver_pb.v new file mode 100644 index 0000000..58340d0 --- /dev/null +++ b/proto/steammessages_clientserver_pb.v @@ -0,0 +1,16692 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +[_allow_multiple_values] +enum EMmslobbyStatus { +k_emmslobbystatusinvalid = 0 +k_emmslobbystatusexists = 1 +k_emmslobbystatusdoesnotexist = 2 +k_emmslobbystatusnotamember = 3 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_emmslobbystatus(e EMmslobbyStatus, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_emmslobbystatus(buf []byte, tag_wiretype vproto.WireType) ?(int, EMmslobbyStatus) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EMmslobbyStatus(v) +} +pub struct CMsgClientUDsp2PSessionStarted { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid_remote u64 +has_steamid_remote bool +appid int +has_appid bool +} +pub fn (o &CMsgClientUDsp2PSessionStarted) pack() []byte { +mut res := []byte{} +if o.has_steamid_remote { +res << vproto.pack_64bit_field(o.steamid_remote, 1) +} + +if o.has_appid { +res << vproto.pack_int32_field(o.appid, 2) +} + +return res +} + +pub fn cmsgclientudsp2psessionstarted_unpack(buf []byte) ?CMsgClientUDsp2PSessionStarted { +mut res := CMsgClientUDsp2PSessionStarted{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid_remote = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_remote = v +i = ii +} + +2 { +res.has_appid = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientudsp2psessionstarted() CMsgClientUDsp2PSessionStarted { +return CMsgClientUDsp2PSessionStarted{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientudsp2psessionstarted(o CMsgClientUDsp2PSessionStarted, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientudsp2psessionstarted(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUDsp2PSessionStarted) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientudsp2psessionstarted_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUDsp2PSessionEnded { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid_remote u64 +has_steamid_remote bool +appid int +has_appid bool +session_length_sec int +has_session_length_sec bool +session_error int +has_session_error bool +nattype int +has_nattype bool +bytes_recv int +has_bytes_recv bool +bytes_sent int +has_bytes_sent bool +bytes_sent_relay int +has_bytes_sent_relay bool +bytes_recv_relay int +has_bytes_recv_relay bool +time_to_connect_ms int +has_time_to_connect_ms bool +} +pub fn (o &CMsgClientUDsp2PSessionEnded) pack() []byte { +mut res := []byte{} +if o.has_steamid_remote { +res << vproto.pack_64bit_field(o.steamid_remote, 1) +} + +if o.has_appid { +res << vproto.pack_int32_field(o.appid, 2) +} + +if o.has_session_length_sec { +res << vproto.pack_int32_field(o.session_length_sec, 3) +} + +if o.has_session_error { +res << vproto.pack_int32_field(o.session_error, 4) +} + +if o.has_nattype { +res << vproto.pack_int32_field(o.nattype, 5) +} + +if o.has_bytes_recv { +res << vproto.pack_int32_field(o.bytes_recv, 6) +} + +if o.has_bytes_sent { +res << vproto.pack_int32_field(o.bytes_sent, 7) +} + +if o.has_bytes_sent_relay { +res << vproto.pack_int32_field(o.bytes_sent_relay, 8) +} + +if o.has_bytes_recv_relay { +res << vproto.pack_int32_field(o.bytes_recv_relay, 9) +} + +if o.has_time_to_connect_ms { +res << vproto.pack_int32_field(o.time_to_connect_ms, 10) +} + +return res +} + +pub fn cmsgclientudsp2psessionended_unpack(buf []byte) ?CMsgClientUDsp2PSessionEnded { +mut res := CMsgClientUDsp2PSessionEnded{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid_remote = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_remote = v +i = ii +} + +2 { +res.has_appid = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +3 { +res.has_session_length_sec = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.session_length_sec = v +i = ii +} + +4 { +res.has_session_error = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.session_error = v +i = ii +} + +5 { +res.has_nattype = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.nattype = v +i = ii +} + +6 { +res.has_bytes_recv = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.bytes_recv = v +i = ii +} + +7 { +res.has_bytes_sent = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.bytes_sent = v +i = ii +} + +8 { +res.has_bytes_sent_relay = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.bytes_sent_relay = v +i = ii +} + +9 { +res.has_bytes_recv_relay = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.bytes_recv_relay = v +i = ii +} + +10 { +res.has_time_to_connect_ms = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.time_to_connect_ms = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientudsp2psessionended() CMsgClientUDsp2PSessionEnded { +return CMsgClientUDsp2PSessionEnded{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientudsp2psessionended(o CMsgClientUDsp2PSessionEnded, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientudsp2psessionended(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUDsp2PSessionEnded) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientudsp2psessionended_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRegisterAuthTicketWithCM { +mut: +unknown_fields []vproto.UnknownField +pub mut: +protocol_version u32 +has_protocol_version bool +ticket []byte +has_ticket bool +client_instance_id u64 +has_client_instance_id bool +} +pub fn (o &CMsgClientRegisterAuthTicketWithCM) pack() []byte { +mut res := []byte{} +if o.has_protocol_version { +res << vproto.pack_uint32_field(o.protocol_version, 1) +} + +if o.has_ticket { +res << vproto.pack_bytes_field(o.ticket, 3) +} + +if o.has_client_instance_id { +res << vproto.pack_uint64_field(o.client_instance_id, 4) +} + +return res +} + +pub fn cmsgclientregisterauthticketwithcm_unpack(buf []byte) ?CMsgClientRegisterAuthTicketWithCM { +mut res := CMsgClientRegisterAuthTicketWithCM{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_protocol_version = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.protocol_version = v +i = ii +} + +3 { +res.has_ticket = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.ticket = v +i = ii +} + +4 { +res.has_client_instance_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.client_instance_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientregisterauthticketwithcm() CMsgClientRegisterAuthTicketWithCM { +return CMsgClientRegisterAuthTicketWithCM{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientregisterauthticketwithcm(o CMsgClientRegisterAuthTicketWithCM, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientregisterauthticketwithcm(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRegisterAuthTicketWithCM) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientregisterauthticketwithcm_unpack(v)? +return i, unpacked +} +pub struct CMsgClientTicketAuthComplete { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id u64 +has_steam_id bool +game_id u64 +has_game_id bool +estate u32 +has_estate bool +eauth_session_response u32 +has_eauth_session_response bool +deprecated_ticket []byte +has_deprecated_ticket bool +ticket_crc u32 +has_ticket_crc bool +ticket_sequence u32 +has_ticket_sequence bool +owner_steam_id u64 +has_owner_steam_id bool +} +pub fn (o &CMsgClientTicketAuthComplete) pack() []byte { +mut res := []byte{} +if o.has_steam_id { +res << vproto.pack_64bit_field(o.steam_id, 1) +} + +if o.has_game_id { +res << vproto.pack_64bit_field(o.game_id, 2) +} + +if o.has_estate { +res << vproto.pack_uint32_field(o.estate, 3) +} + +if o.has_eauth_session_response { +res << vproto.pack_uint32_field(o.eauth_session_response, 4) +} + +if o.has_deprecated_ticket { +res << vproto.pack_bytes_field(o.deprecated_ticket, 5) +} + +if o.has_ticket_crc { +res << vproto.pack_uint32_field(o.ticket_crc, 6) +} + +if o.has_ticket_sequence { +res << vproto.pack_uint32_field(o.ticket_sequence, 7) +} + +if o.has_owner_steam_id { +res << vproto.pack_64bit_field(o.owner_steam_id, 8) +} + +return res +} + +pub fn cmsgclientticketauthcomplete_unpack(buf []byte) ?CMsgClientTicketAuthComplete { +mut res := CMsgClientTicketAuthComplete{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id = v +i = ii +} + +2 { +res.has_game_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.game_id = v +i = ii +} + +3 { +res.has_estate = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.estate = v +i = ii +} + +4 { +res.has_eauth_session_response = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eauth_session_response = v +i = ii +} + +5 { +res.has_deprecated_ticket = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated_ticket = v +i = ii +} + +6 { +res.has_ticket_crc = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ticket_crc = v +i = ii +} + +7 { +res.has_ticket_sequence = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ticket_sequence = v +i = ii +} + +8 { +res.has_owner_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.owner_steam_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientticketauthcomplete() CMsgClientTicketAuthComplete { +return CMsgClientTicketAuthComplete{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientticketauthcomplete(o CMsgClientTicketAuthComplete, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientticketauthcomplete(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientTicketAuthComplete) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientticketauthcomplete_unpack(v)? +return i, unpacked +} +pub struct CMsgClientCMlist { +mut: +unknown_fields []vproto.UnknownField +pub mut: +cm_addresses []u32 +cm_ports []u32 +cm_websocket_addresses []string +percent_default_to_websocket u32 +has_percent_default_to_websocket bool +} +pub fn (o &CMsgClientCMlist) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.cm_addresses { +res << vproto.pack_uint32_field(x, 1) +} + +// [packed=false] +for _, x in o.cm_ports { +res << vproto.pack_uint32_field(x, 2) +} + +// [packed=false] +for _, x in o.cm_websocket_addresses { +res << vproto.pack_string_field(x, 3) +} + +if o.has_percent_default_to_websocket { +res << vproto.pack_uint32_field(o.percent_default_to_websocket, 4) +} + +return res +} + +pub fn cmsgclientcmlist_unpack(buf []byte) ?CMsgClientCMlist { +mut res := CMsgClientCMlist{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cm_addresses << v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cm_ports << v +i = ii +} + +3 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.cm_websocket_addresses << v +i = ii +} + +4 { +res.has_percent_default_to_websocket = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.percent_default_to_websocket = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientcmlist() CMsgClientCMlist { +return CMsgClientCMlist{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientcmlist(o CMsgClientCMlist, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientcmlist(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientCMlist) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientcmlist_unpack(v)? +return i, unpacked +} +pub struct CMsgClientP2PConnectionInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id_dest u64 +has_steam_id_dest bool +steam_id_src u64 +has_steam_id_src bool +app_id u32 +has_app_id bool +candidate []byte +has_candidate bool +connection_id_src u64 +has_connection_id_src bool +rendezvous []byte +has_rendezvous bool +} +pub fn (o &CMsgClientP2PConnectionInfo) pack() []byte { +mut res := []byte{} +if o.has_steam_id_dest { +res << vproto.pack_64bit_field(o.steam_id_dest, 1) +} + +if o.has_steam_id_src { +res << vproto.pack_64bit_field(o.steam_id_src, 2) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 3) +} + +if o.has_candidate { +res << vproto.pack_bytes_field(o.candidate, 4) +} + +if o.has_connection_id_src { +res << vproto.pack_64bit_field(o.connection_id_src, 5) +} + +if o.has_rendezvous { +res << vproto.pack_bytes_field(o.rendezvous, 6) +} + +return res +} + +pub fn cmsgclientp2pconnectioninfo_unpack(buf []byte) ?CMsgClientP2PConnectionInfo { +mut res := CMsgClientP2PConnectionInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id_dest = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_dest = v +i = ii +} + +2 { +res.has_steam_id_src = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_src = v +i = ii +} + +3 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +4 { +res.has_candidate = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.candidate = v +i = ii +} + +5 { +res.has_connection_id_src = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.connection_id_src = v +i = ii +} + +6 { +res.has_rendezvous = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.rendezvous = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientp2pconnectioninfo() CMsgClientP2PConnectionInfo { +return CMsgClientP2PConnectionInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientp2pconnectioninfo(o CMsgClientP2PConnectionInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientp2pconnectioninfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientP2PConnectionInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientp2pconnectioninfo_unpack(v)? +return i, unpacked +} +pub struct CMsgClientP2PConnectionFailInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id_dest u64 +has_steam_id_dest bool +steam_id_src u64 +has_steam_id_src bool +app_id u32 +has_app_id bool +ep2p_session_error u32 +has_ep2p_session_error bool +connection_id_dest u64 +has_connection_id_dest bool +close_reason u32 +has_close_reason bool +close_message string +has_close_message bool +} +pub fn (o &CMsgClientP2PConnectionFailInfo) pack() []byte { +mut res := []byte{} +if o.has_steam_id_dest { +res << vproto.pack_64bit_field(o.steam_id_dest, 1) +} + +if o.has_steam_id_src { +res << vproto.pack_64bit_field(o.steam_id_src, 2) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 3) +} + +if o.has_ep2p_session_error { +res << vproto.pack_uint32_field(o.ep2p_session_error, 4) +} + +if o.has_connection_id_dest { +res << vproto.pack_64bit_field(o.connection_id_dest, 5) +} + +if o.has_close_reason { +res << vproto.pack_uint32_field(o.close_reason, 7) +} + +if o.has_close_message { +res << vproto.pack_string_field(o.close_message, 8) +} + +return res +} + +pub fn cmsgclientp2pconnectionfailinfo_unpack(buf []byte) ?CMsgClientP2PConnectionFailInfo { +mut res := CMsgClientP2PConnectionFailInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id_dest = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_dest = v +i = ii +} + +2 { +res.has_steam_id_src = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_src = v +i = ii +} + +3 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +4 { +res.has_ep2p_session_error = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ep2p_session_error = v +i = ii +} + +5 { +res.has_connection_id_dest = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.connection_id_dest = v +i = ii +} + +7 { +res.has_close_reason = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.close_reason = v +i = ii +} + +8 { +res.has_close_message = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.close_message = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientp2pconnectionfailinfo() CMsgClientP2PConnectionFailInfo { +return CMsgClientP2PConnectionFailInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientp2pconnectionfailinfo(o CMsgClientP2PConnectionFailInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientp2pconnectionfailinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientP2PConnectionFailInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientp2pconnectionfailinfo_unpack(v)? +return i, unpacked +} +pub struct CMsgClientNetworkingCertRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +key_data []byte +has_key_data bool +app_id u32 +has_app_id bool +} +pub fn (o &CMsgClientNetworkingCertRequest) pack() []byte { +mut res := []byte{} +if o.has_key_data { +res << vproto.pack_bytes_field(o.key_data, 2) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 3) +} + +return res +} + +pub fn cmsgclientnetworkingcertrequest_unpack(buf []byte) ?CMsgClientNetworkingCertRequest { +mut res := CMsgClientNetworkingCertRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +2 { +res.has_key_data = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.key_data = v +i = ii +} + +3 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientnetworkingcertrequest() CMsgClientNetworkingCertRequest { +return CMsgClientNetworkingCertRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientnetworkingcertrequest(o CMsgClientNetworkingCertRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientnetworkingcertrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientNetworkingCertRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientnetworkingcertrequest_unpack(v)? +return i, unpacked +} +pub struct CMsgClientNetworkingCertReply { +mut: +unknown_fields []vproto.UnknownField +pub mut: +cert []byte +has_cert bool +ca_key_id u64 +has_ca_key_id bool +ca_signature []byte +has_ca_signature bool +} +pub fn (o &CMsgClientNetworkingCertReply) pack() []byte { +mut res := []byte{} +if o.has_cert { +res << vproto.pack_bytes_field(o.cert, 4) +} + +if o.has_ca_key_id { +res << vproto.pack_64bit_field(o.ca_key_id, 5) +} + +if o.has_ca_signature { +res << vproto.pack_bytes_field(o.ca_signature, 6) +} + +return res +} + +pub fn cmsgclientnetworkingcertreply_unpack(buf []byte) ?CMsgClientNetworkingCertReply { +mut res := CMsgClientNetworkingCertReply{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +4 { +res.has_cert = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.cert = v +i = ii +} + +5 { +res.has_ca_key_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.ca_key_id = v +i = ii +} + +6 { +res.has_ca_signature = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.ca_signature = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientnetworkingcertreply() CMsgClientNetworkingCertReply { +return CMsgClientNetworkingCertReply{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientnetworkingcertreply(o CMsgClientNetworkingCertReply, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientnetworkingcertreply(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientNetworkingCertReply) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientnetworkingcertreply_unpack(v)? +return i, unpacked +} +pub struct CMsgClientNetworkingMobileCertRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +} +pub fn (o &CMsgClientNetworkingMobileCertRequest) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +return res +} + +pub fn cmsgclientnetworkingmobilecertrequest_unpack(buf []byte) ?CMsgClientNetworkingMobileCertRequest { +mut res := CMsgClientNetworkingMobileCertRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientnetworkingmobilecertrequest() CMsgClientNetworkingMobileCertRequest { +return CMsgClientNetworkingMobileCertRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientnetworkingmobilecertrequest(o CMsgClientNetworkingMobileCertRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientnetworkingmobilecertrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientNetworkingMobileCertRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientnetworkingmobilecertrequest_unpack(v)? +return i, unpacked +} +pub struct CMsgClientNetworkingMobileCertReply { +mut: +unknown_fields []vproto.UnknownField +pub mut: +encoded_cert string +has_encoded_cert bool +} +pub fn (o &CMsgClientNetworkingMobileCertReply) pack() []byte { +mut res := []byte{} +if o.has_encoded_cert { +res << vproto.pack_string_field(o.encoded_cert, 1) +} + +return res +} + +pub fn cmsgclientnetworkingmobilecertreply_unpack(buf []byte) ?CMsgClientNetworkingMobileCertReply { +mut res := CMsgClientNetworkingMobileCertReply{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_encoded_cert = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.encoded_cert = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientnetworkingmobilecertreply() CMsgClientNetworkingMobileCertReply { +return CMsgClientNetworkingMobileCertReply{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientnetworkingmobilecertreply(o CMsgClientNetworkingMobileCertReply, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientnetworkingmobilecertreply(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientNetworkingMobileCertReply) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientnetworkingmobilecertreply_unpack(v)? +return i, unpacked +} +pub struct CMsgClientGetAppOwnershipTicket { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +} +pub fn (o &CMsgClientGetAppOwnershipTicket) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +return res +} + +pub fn cmsgclientgetappownershipticket_unpack(buf []byte) ?CMsgClientGetAppOwnershipTicket { +mut res := CMsgClientGetAppOwnershipTicket{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientgetappownershipticket() CMsgClientGetAppOwnershipTicket { +return CMsgClientGetAppOwnershipTicket{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientgetappownershipticket(o CMsgClientGetAppOwnershipTicket, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientgetappownershipticket(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientGetAppOwnershipTicket) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientgetappownershipticket_unpack(v)? +return i, unpacked +} +pub struct CMsgClientGetAppOwnershipTicketResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult u32 +has_eresult bool +app_id u32 +has_app_id bool +ticket []byte +has_ticket bool +} +pub fn (o &CMsgClientGetAppOwnershipTicketResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_uint32_field(o.eresult, 1) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 2) +} + +if o.has_ticket { +res << vproto.pack_bytes_field(o.ticket, 3) +} + +return res +} + +pub fn cmsgclientgetappownershipticketresponse_unpack(buf []byte) ?CMsgClientGetAppOwnershipTicketResponse { +mut res := CMsgClientGetAppOwnershipTicketResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +3 { +res.has_ticket = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.ticket = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientgetappownershipticketresponse() CMsgClientGetAppOwnershipTicketResponse { +return CMsgClientGetAppOwnershipTicketResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientgetappownershipticketresponse(o CMsgClientGetAppOwnershipTicketResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientgetappownershipticketresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientGetAppOwnershipTicketResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientgetappownershipticketresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientSessionToken { +mut: +unknown_fields []vproto.UnknownField +pub mut: +token u64 +has_token bool +} +pub fn (o &CMsgClientSessionToken) pack() []byte { +mut res := []byte{} +if o.has_token { +res << vproto.pack_uint64_field(o.token, 1) +} + +return res +} + +pub fn cmsgclientsessiontoken_unpack(buf []byte) ?CMsgClientSessionToken { +mut res := CMsgClientSessionToken{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_token = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientsessiontoken() CMsgClientSessionToken { +return CMsgClientSessionToken{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientsessiontoken(o CMsgClientSessionToken, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientsessiontoken(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientSessionToken) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientsessiontoken_unpack(v)? +return i, unpacked +} +pub struct CMsgClientGameConnectTokens { +mut: +unknown_fields []vproto.UnknownField +pub mut: +max_tokens_to_keep u32 +has_max_tokens_to_keep bool +tokens [][]byte +} +pub fn (o &CMsgClientGameConnectTokens) pack() []byte { +mut res := []byte{} +if o.has_max_tokens_to_keep { +res << vproto.pack_uint32_field(o.max_tokens_to_keep, 1) +} + +// [packed=false] +for _, x in o.tokens { +res << vproto.pack_bytes_field(x, 2) +} + +return res +} + +pub fn cmsgclientgameconnecttokens_unpack(buf []byte) ?CMsgClientGameConnectTokens { +mut res := CMsgClientGameConnectTokens{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_max_tokens_to_keep = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.max_tokens_to_keep = v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.tokens << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientgameconnecttokens() CMsgClientGameConnectTokens { +return CMsgClientGameConnectTokens{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientgameconnecttokens(o CMsgClientGameConnectTokens, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientgameconnecttokens(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientGameConnectTokens) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientgameconnecttokens_unpack(v)? +return i, unpacked +} +pub struct CMsgGSserverType { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id_served u32 +has_app_id_served bool +flags u32 +has_flags bool +deprecated_game_ip_address u32 +has_deprecated_game_ip_address bool +game_port u32 +has_game_port bool +game_dir string +has_game_dir bool +game_version string +has_game_version bool +game_query_port u32 +has_game_query_port bool +} +pub fn (o &CMsgGSserverType) pack() []byte { +mut res := []byte{} +if o.has_app_id_served { +res << vproto.pack_uint32_field(o.app_id_served, 1) +} + +if o.has_flags { +res << vproto.pack_uint32_field(o.flags, 2) +} + +if o.has_deprecated_game_ip_address { +res << vproto.pack_uint32_field(o.deprecated_game_ip_address, 3) +} + +if o.has_game_port { +res << vproto.pack_uint32_field(o.game_port, 4) +} + +if o.has_game_dir { +res << vproto.pack_string_field(o.game_dir, 5) +} + +if o.has_game_version { +res << vproto.pack_string_field(o.game_version, 6) +} + +if o.has_game_query_port { +res << vproto.pack_uint32_field(o.game_query_port, 7) +} + +return res +} + +pub fn cmsggsservertype_unpack(buf []byte) ?CMsgGSserverType { +mut res := CMsgGSserverType{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id_served = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id_served = v +i = ii +} + +2 { +res.has_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.flags = v +i = ii +} + +3 { +res.has_deprecated_game_ip_address = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated_game_ip_address = v +i = ii +} + +4 { +res.has_game_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.game_port = v +i = ii +} + +5 { +res.has_game_dir = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.game_dir = v +i = ii +} + +6 { +res.has_game_version = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.game_version = v +i = ii +} + +7 { +res.has_game_query_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.game_query_port = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggsservertype() CMsgGSserverType { +return CMsgGSserverType{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggsservertype(o CMsgGSserverType, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggsservertype(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGSserverType) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggsservertype_unpack(v)? +return i, unpacked +} +pub struct CMsgGSstatusReply { +mut: +unknown_fields []vproto.UnknownField +pub mut: +is_secure bool +has_is_secure bool +} +pub fn (o &CMsgGSstatusReply) pack() []byte { +mut res := []byte{} +if o.has_is_secure { +res << vproto.pack_bool_field(o.is_secure, 1) +} + +return res +} + +pub fn cmsggsstatusreply_unpack(buf []byte) ?CMsgGSstatusReply { +mut res := CMsgGSstatusReply{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_is_secure = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_secure = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggsstatusreply() CMsgGSstatusReply { +return CMsgGSstatusReply{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggsstatusreply(o CMsgGSstatusReply, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggsstatusreply(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGSstatusReply) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggsstatusreply_unpack(v)? +return i, unpacked +} +pub struct CMsgGSplayerListPlayer { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id u64 +has_steam_id bool +deprecated_public_ip u32 +has_deprecated_public_ip bool +token []byte +has_token bool +public_ip CMsgIPaddress +has_public_ip bool +} +pub fn (o &CMsgGSplayerListPlayer) pack() []byte { +mut res := []byte{} +if o.has_steam_id { +res << vproto.pack_uint64_field(o.steam_id, 1) +} + +if o.has_deprecated_public_ip { +res << vproto.pack_uint32_field(o.deprecated_public_ip, 2) +} + +if o.has_token { +res << vproto.pack_bytes_field(o.token, 3) +} + +if o.has_public_ip { +res << zzz_vproto_internal_pack_cmsgipaddress(o.public_ip, 4) +} + +return res +} + +pub fn cmsggsplayerlistplayer_unpack(buf []byte) ?CMsgGSplayerListPlayer { +mut res := CMsgGSplayerListPlayer{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id = v +i = ii +} + +2 { +res.has_deprecated_public_ip = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated_public_ip = v +i = ii +} + +3 { +res.has_token = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.token = v +i = ii +} + +4 { +res.has_public_ip = true +ii, v := zzz_vproto_internal_unpack_cmsgipaddress(cur_buf, tag_wiretype.wire_type)? +res.public_ip = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggsplayerlistplayer() CMsgGSplayerListPlayer { +return CMsgGSplayerListPlayer{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggsplayerlistplayer(o CMsgGSplayerListPlayer, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggsplayerlistplayer(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGSplayerListPlayer) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggsplayerlistplayer_unpack(v)? +return i, unpacked +} +pub struct CMsgGSplayerList { +mut: +unknown_fields []vproto.UnknownField +pub mut: +players []CMsgGSplayerListPlayer +} +pub fn (o &CMsgGSplayerList) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.players { +res << zzz_vproto_internal_pack_cmsggsplayerlistplayer(x, 1) +} + +return res +} + +pub fn cmsggsplayerlist_unpack(buf []byte) ?CMsgGSplayerList { +mut res := CMsgGSplayerList{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsggsplayerlistplayer(cur_buf, tag_wiretype.wire_type)? +res.players << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggsplayerlist() CMsgGSplayerList { +return CMsgGSplayerList{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggsplayerlist(o CMsgGSplayerList, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggsplayerlist(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGSplayerList) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggsplayerlist_unpack(v)? +return i, unpacked +} +pub struct CMsgGSuserPlaying { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id u64 +has_steam_id bool +deprecated_public_ip u32 +has_deprecated_public_ip bool +token []byte +has_token bool +public_ip CMsgIPaddress +has_public_ip bool +} +pub fn (o &CMsgGSuserPlaying) pack() []byte { +mut res := []byte{} +if o.has_steam_id { +res << vproto.pack_64bit_field(o.steam_id, 1) +} + +if o.has_deprecated_public_ip { +res << vproto.pack_uint32_field(o.deprecated_public_ip, 2) +} + +if o.has_token { +res << vproto.pack_bytes_field(o.token, 3) +} + +if o.has_public_ip { +res << zzz_vproto_internal_pack_cmsgipaddress(o.public_ip, 4) +} + +return res +} + +pub fn cmsggsuserplaying_unpack(buf []byte) ?CMsgGSuserPlaying { +mut res := CMsgGSuserPlaying{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id = v +i = ii +} + +2 { +res.has_deprecated_public_ip = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated_public_ip = v +i = ii +} + +3 { +res.has_token = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.token = v +i = ii +} + +4 { +res.has_public_ip = true +ii, v := zzz_vproto_internal_unpack_cmsgipaddress(cur_buf, tag_wiretype.wire_type)? +res.public_ip = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggsuserplaying() CMsgGSuserPlaying { +return CMsgGSuserPlaying{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggsuserplaying(o CMsgGSuserPlaying, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggsuserplaying(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGSuserPlaying) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggsuserplaying_unpack(v)? +return i, unpacked +} +pub struct CMsgGSdisconnectNotice { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id u64 +has_steam_id bool +} +pub fn (o &CMsgGSdisconnectNotice) pack() []byte { +mut res := []byte{} +if o.has_steam_id { +res << vproto.pack_64bit_field(o.steam_id, 1) +} + +return res +} + +pub fn cmsggsdisconnectnotice_unpack(buf []byte) ?CMsgGSdisconnectNotice { +mut res := CMsgGSdisconnectNotice{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggsdisconnectnotice() CMsgGSdisconnectNotice { +return CMsgGSdisconnectNotice{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggsdisconnectnotice(o CMsgGSdisconnectNotice, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggsdisconnectnotice(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGSdisconnectNotice) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggsdisconnectnotice_unpack(v)? +return i, unpacked +} +pub struct CMsgClientGamesPlayedGamePlayed { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id_gs u64 +has_steam_id_gs bool +game_id u64 +has_game_id bool +deprecated_game_ip_address u32 +has_deprecated_game_ip_address bool +game_port u32 +has_game_port bool +is_secure bool +has_is_secure bool +token []byte +has_token bool +game_extra_info string +has_game_extra_info bool +game_data_blob []byte +has_game_data_blob bool +process_id u32 +has_process_id bool +streaming_provider_id u32 +has_streaming_provider_id bool +game_flags u32 +has_game_flags bool +owner_id u32 +has_owner_id bool +vr_hmd_vendor string +has_vr_hmd_vendor bool +vr_hmd_model string +has_vr_hmd_model bool +launch_option_type u32 +has_launch_option_type bool +primary_controller_type int +has_primary_controller_type bool +primary_steam_controller_serial string +has_primary_steam_controller_serial bool +total_steam_controller_count u32 +has_total_steam_controller_count bool +total_non_steam_controller_count u32 +has_total_non_steam_controller_count bool +controller_workshop_file_id u64 +has_controller_workshop_file_id bool +launch_source u32 +has_launch_source bool +vr_hmd_runtime u32 +has_vr_hmd_runtime bool +game_ip_address CMsgIPaddress +has_game_ip_address bool +controller_connection_type u32 +has_controller_connection_type bool +} +pub fn (o &CMsgClientGamesPlayedGamePlayed) pack() []byte { +mut res := []byte{} +if o.has_steam_id_gs { +res << vproto.pack_uint64_field(o.steam_id_gs, 1) +} + +if o.has_game_id { +res << vproto.pack_64bit_field(o.game_id, 2) +} + +if o.has_deprecated_game_ip_address { +res << vproto.pack_uint32_field(o.deprecated_game_ip_address, 3) +} + +if o.has_game_port { +res << vproto.pack_uint32_field(o.game_port, 4) +} + +if o.has_is_secure { +res << vproto.pack_bool_field(o.is_secure, 5) +} + +if o.has_token { +res << vproto.pack_bytes_field(o.token, 6) +} + +if o.has_game_extra_info { +res << vproto.pack_string_field(o.game_extra_info, 7) +} + +if o.has_game_data_blob { +res << vproto.pack_bytes_field(o.game_data_blob, 8) +} + +if o.has_process_id { +res << vproto.pack_uint32_field(o.process_id, 9) +} + +if o.has_streaming_provider_id { +res << vproto.pack_uint32_field(o.streaming_provider_id, 10) +} + +if o.has_game_flags { +res << vproto.pack_uint32_field(o.game_flags, 11) +} + +if o.has_owner_id { +res << vproto.pack_uint32_field(o.owner_id, 12) +} + +if o.has_vr_hmd_vendor { +res << vproto.pack_string_field(o.vr_hmd_vendor, 13) +} + +if o.has_vr_hmd_model { +res << vproto.pack_string_field(o.vr_hmd_model, 14) +} + +if o.has_launch_option_type { +res << vproto.pack_uint32_field(o.launch_option_type, 15) +} + +if o.has_primary_controller_type { +res << vproto.pack_int32_field(o.primary_controller_type, 16) +} + +if o.has_primary_steam_controller_serial { +res << vproto.pack_string_field(o.primary_steam_controller_serial, 17) +} + +if o.has_total_steam_controller_count { +res << vproto.pack_uint32_field(o.total_steam_controller_count, 18) +} + +if o.has_total_non_steam_controller_count { +res << vproto.pack_uint32_field(o.total_non_steam_controller_count, 19) +} + +if o.has_controller_workshop_file_id { +res << vproto.pack_uint64_field(o.controller_workshop_file_id, 20) +} + +if o.has_launch_source { +res << vproto.pack_uint32_field(o.launch_source, 21) +} + +if o.has_vr_hmd_runtime { +res << vproto.pack_uint32_field(o.vr_hmd_runtime, 22) +} + +if o.has_game_ip_address { +res << zzz_vproto_internal_pack_cmsgipaddress(o.game_ip_address, 23) +} + +if o.has_controller_connection_type { +res << vproto.pack_uint32_field(o.controller_connection_type, 24) +} + +return res +} + +pub fn cmsgclientgamesplayedgameplayed_unpack(buf []byte) ?CMsgClientGamesPlayedGamePlayed { +mut res := CMsgClientGamesPlayedGamePlayed{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id_gs = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_gs = v +i = ii +} + +2 { +res.has_game_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.game_id = v +i = ii +} + +3 { +res.has_deprecated_game_ip_address = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated_game_ip_address = v +i = ii +} + +4 { +res.has_game_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.game_port = v +i = ii +} + +5 { +res.has_is_secure = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_secure = v +i = ii +} + +6 { +res.has_token = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.token = v +i = ii +} + +7 { +res.has_game_extra_info = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.game_extra_info = v +i = ii +} + +8 { +res.has_game_data_blob = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.game_data_blob = v +i = ii +} + +9 { +res.has_process_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.process_id = v +i = ii +} + +10 { +res.has_streaming_provider_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.streaming_provider_id = v +i = ii +} + +11 { +res.has_game_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.game_flags = v +i = ii +} + +12 { +res.has_owner_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.owner_id = v +i = ii +} + +13 { +res.has_vr_hmd_vendor = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.vr_hmd_vendor = v +i = ii +} + +14 { +res.has_vr_hmd_model = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.vr_hmd_model = v +i = ii +} + +15 { +res.has_launch_option_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.launch_option_type = v +i = ii +} + +16 { +res.has_primary_controller_type = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.primary_controller_type = v +i = ii +} + +17 { +res.has_primary_steam_controller_serial = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.primary_steam_controller_serial = v +i = ii +} + +18 { +res.has_total_steam_controller_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.total_steam_controller_count = v +i = ii +} + +19 { +res.has_total_non_steam_controller_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.total_non_steam_controller_count = v +i = ii +} + +20 { +res.has_controller_workshop_file_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.controller_workshop_file_id = v +i = ii +} + +21 { +res.has_launch_source = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.launch_source = v +i = ii +} + +22 { +res.has_vr_hmd_runtime = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.vr_hmd_runtime = v +i = ii +} + +23 { +res.has_game_ip_address = true +ii, v := zzz_vproto_internal_unpack_cmsgipaddress(cur_buf, tag_wiretype.wire_type)? +res.game_ip_address = v +i = ii +} + +24 { +res.has_controller_connection_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.controller_connection_type = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientgamesplayedgameplayed() CMsgClientGamesPlayedGamePlayed { +return CMsgClientGamesPlayedGamePlayed{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientgamesplayedgameplayed(o CMsgClientGamesPlayedGamePlayed, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientgamesplayedgameplayed(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientGamesPlayedGamePlayed) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientgamesplayedgameplayed_unpack(v)? +return i, unpacked +} +pub struct CMsgClientGamesPlayed { +mut: +unknown_fields []vproto.UnknownField +pub mut: +games_played []CMsgClientGamesPlayedGamePlayed +client_os_type u32 +has_client_os_type bool +cloud_gaming_platform u32 +has_cloud_gaming_platform bool +} +pub fn (o &CMsgClientGamesPlayed) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.games_played { +res << zzz_vproto_internal_pack_cmsgclientgamesplayedgameplayed(x, 1) +} + +if o.has_client_os_type { +res << vproto.pack_uint32_field(o.client_os_type, 2) +} + +if o.has_cloud_gaming_platform { +res << vproto.pack_uint32_field(o.cloud_gaming_platform, 3) +} + +return res +} + +pub fn cmsgclientgamesplayed_unpack(buf []byte) ?CMsgClientGamesPlayed { +mut res := CMsgClientGamesPlayed{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientgamesplayedgameplayed(cur_buf, tag_wiretype.wire_type)? +res.games_played << v +i = ii +} + +2 { +res.has_client_os_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.client_os_type = v +i = ii +} + +3 { +res.has_cloud_gaming_platform = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cloud_gaming_platform = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientgamesplayed() CMsgClientGamesPlayed { +return CMsgClientGamesPlayed{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientgamesplayed(o CMsgClientGamesPlayed, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientgamesplayed(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientGamesPlayed) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientgamesplayed_unpack(v)? +return i, unpacked +} +pub struct CMsgGSapprove { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id u64 +has_steam_id bool +owner_steam_id u64 +has_owner_steam_id bool +} +pub fn (o &CMsgGSapprove) pack() []byte { +mut res := []byte{} +if o.has_steam_id { +res << vproto.pack_64bit_field(o.steam_id, 1) +} + +if o.has_owner_steam_id { +res << vproto.pack_64bit_field(o.owner_steam_id, 2) +} + +return res +} + +pub fn cmsggsapprove_unpack(buf []byte) ?CMsgGSapprove { +mut res := CMsgGSapprove{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id = v +i = ii +} + +2 { +res.has_owner_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.owner_steam_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggsapprove() CMsgGSapprove { +return CMsgGSapprove{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggsapprove(o CMsgGSapprove, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggsapprove(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGSapprove) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggsapprove_unpack(v)? +return i, unpacked +} +pub struct CMsgGSdeny { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id u64 +has_steam_id bool +edeny_reason int +has_edeny_reason bool +deny_string string +has_deny_string bool +} +pub fn (o &CMsgGSdeny) pack() []byte { +mut res := []byte{} +if o.has_steam_id { +res << vproto.pack_64bit_field(o.steam_id, 1) +} + +if o.has_edeny_reason { +res << vproto.pack_int32_field(o.edeny_reason, 2) +} + +if o.has_deny_string { +res << vproto.pack_string_field(o.deny_string, 3) +} + +return res +} + +pub fn cmsggsdeny_unpack(buf []byte) ?CMsgGSdeny { +mut res := CMsgGSdeny{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id = v +i = ii +} + +2 { +res.has_edeny_reason = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.edeny_reason = v +i = ii +} + +3 { +res.has_deny_string = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.deny_string = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggsdeny() CMsgGSdeny { +return CMsgGSdeny{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggsdeny(o CMsgGSdeny, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggsdeny(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGSdeny) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggsdeny_unpack(v)? +return i, unpacked +} +pub struct CMsgGSkick { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id u64 +has_steam_id bool +edeny_reason int +has_edeny_reason bool +} +pub fn (o &CMsgGSkick) pack() []byte { +mut res := []byte{} +if o.has_steam_id { +res << vproto.pack_64bit_field(o.steam_id, 1) +} + +if o.has_edeny_reason { +res << vproto.pack_int32_field(o.edeny_reason, 2) +} + +return res +} + +pub fn cmsggskick_unpack(buf []byte) ?CMsgGSkick { +mut res := CMsgGSkick{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id = v +i = ii +} + +2 { +res.has_edeny_reason = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.edeny_reason = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsggskick() CMsgGSkick { +return CMsgGSkick{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsggskick(o CMsgGSkick, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsggskick(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgGSkick) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsggskick_unpack(v)? +return i, unpacked +} +pub struct CMsgClientAuthList { +mut: +unknown_fields []vproto.UnknownField +pub mut: +tokens_left u32 +has_tokens_left bool +last_request_seq u32 +has_last_request_seq bool +last_request_seq_from_server u32 +has_last_request_seq_from_server bool +tickets []CMsgAuthTicket +app_ids []u32 +message_sequence u32 +has_message_sequence bool +} +pub fn (o &CMsgClientAuthList) pack() []byte { +mut res := []byte{} +if o.has_tokens_left { +res << vproto.pack_uint32_field(o.tokens_left, 1) +} + +if o.has_last_request_seq { +res << vproto.pack_uint32_field(o.last_request_seq, 2) +} + +if o.has_last_request_seq_from_server { +res << vproto.pack_uint32_field(o.last_request_seq_from_server, 3) +} + +// [packed=false] +for _, x in o.tickets { +res << zzz_vproto_internal_pack_cmsgauthticket(x, 4) +} + +// [packed=false] +for _, x in o.app_ids { +res << vproto.pack_uint32_field(x, 5) +} + +if o.has_message_sequence { +res << vproto.pack_uint32_field(o.message_sequence, 6) +} + +return res +} + +pub fn cmsgclientauthlist_unpack(buf []byte) ?CMsgClientAuthList { +mut res := CMsgClientAuthList{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_tokens_left = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.tokens_left = v +i = ii +} + +2 { +res.has_last_request_seq = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_request_seq = v +i = ii +} + +3 { +res.has_last_request_seq_from_server = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_request_seq_from_server = v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgauthticket(cur_buf, tag_wiretype.wire_type)? +res.tickets << v +i = ii +} + +5 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_ids << v +i = ii +} + +6 { +res.has_message_sequence = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.message_sequence = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientauthlist() CMsgClientAuthList { +return CMsgClientAuthList{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientauthlist(o CMsgClientAuthList, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientauthlist(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientAuthList) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientauthlist_unpack(v)? +return i, unpacked +} +pub struct CMsgClientAuthListAck { +mut: +unknown_fields []vproto.UnknownField +pub mut: +ticket_crc []u32 +app_ids []u32 +message_sequence u32 +has_message_sequence bool +} +pub fn (o &CMsgClientAuthListAck) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.ticket_crc { +res << vproto.pack_uint32_field(x, 1) +} + +// [packed=false] +for _, x in o.app_ids { +res << vproto.pack_uint32_field(x, 2) +} + +if o.has_message_sequence { +res << vproto.pack_uint32_field(o.message_sequence, 3) +} + +return res +} + +pub fn cmsgclientauthlistack_unpack(buf []byte) ?CMsgClientAuthListAck { +mut res := CMsgClientAuthListAck{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ticket_crc << v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_ids << v +i = ii +} + +3 { +res.has_message_sequence = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.message_sequence = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientauthlistack() CMsgClientAuthListAck { +return CMsgClientAuthListAck{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientauthlistack(o CMsgClientAuthListAck, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientauthlistack(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientAuthListAck) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientauthlistack_unpack(v)? +return i, unpacked +} +pub struct CMsgClientLicenseListLicense { +mut: +unknown_fields []vproto.UnknownField +pub mut: +package_id u32 +has_package_id bool +time_created u32 +has_time_created bool +time_next_process u32 +has_time_next_process bool +minute_limit int +has_minute_limit bool +minutes_used int +has_minutes_used bool +payment_method u32 +has_payment_method bool +flags u32 +has_flags bool +purchase_country_code string +has_purchase_country_code bool +license_type u32 +has_license_type bool +territory_code int +has_territory_code bool +change_number int +has_change_number bool +owner_id u32 +has_owner_id bool +initial_period u32 +has_initial_period bool +initial_time_unit u32 +has_initial_time_unit bool +renewal_period u32 +has_renewal_period bool +renewal_time_unit u32 +has_renewal_time_unit bool +access_token u64 +has_access_token bool +master_package_id u32 +has_master_package_id bool +} +pub fn (o &CMsgClientLicenseListLicense) pack() []byte { +mut res := []byte{} +if o.has_package_id { +res << vproto.pack_uint32_field(o.package_id, 1) +} + +if o.has_time_created { +res << vproto.pack_32bit_field(o.time_created, 2) +} + +if o.has_time_next_process { +res << vproto.pack_32bit_field(o.time_next_process, 3) +} + +if o.has_minute_limit { +res << vproto.pack_int32_field(o.minute_limit, 4) +} + +if o.has_minutes_used { +res << vproto.pack_int32_field(o.minutes_used, 5) +} + +if o.has_payment_method { +res << vproto.pack_uint32_field(o.payment_method, 6) +} + +if o.has_flags { +res << vproto.pack_uint32_field(o.flags, 7) +} + +if o.has_purchase_country_code { +res << vproto.pack_string_field(o.purchase_country_code, 8) +} + +if o.has_license_type { +res << vproto.pack_uint32_field(o.license_type, 9) +} + +if o.has_territory_code { +res << vproto.pack_int32_field(o.territory_code, 10) +} + +if o.has_change_number { +res << vproto.pack_int32_field(o.change_number, 11) +} + +if o.has_owner_id { +res << vproto.pack_uint32_field(o.owner_id, 12) +} + +if o.has_initial_period { +res << vproto.pack_uint32_field(o.initial_period, 13) +} + +if o.has_initial_time_unit { +res << vproto.pack_uint32_field(o.initial_time_unit, 14) +} + +if o.has_renewal_period { +res << vproto.pack_uint32_field(o.renewal_period, 15) +} + +if o.has_renewal_time_unit { +res << vproto.pack_uint32_field(o.renewal_time_unit, 16) +} + +if o.has_access_token { +res << vproto.pack_uint64_field(o.access_token, 17) +} + +if o.has_master_package_id { +res << vproto.pack_uint32_field(o.master_package_id, 18) +} + +return res +} + +pub fn cmsgclientlicenselistlicense_unpack(buf []byte) ?CMsgClientLicenseListLicense { +mut res := CMsgClientLicenseListLicense{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_package_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.package_id = v +i = ii +} + +2 { +res.has_time_created = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.time_created = v +i = ii +} + +3 { +res.has_time_next_process = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.time_next_process = v +i = ii +} + +4 { +res.has_minute_limit = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.minute_limit = v +i = ii +} + +5 { +res.has_minutes_used = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.minutes_used = v +i = ii +} + +6 { +res.has_payment_method = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.payment_method = v +i = ii +} + +7 { +res.has_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.flags = v +i = ii +} + +8 { +res.has_purchase_country_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.purchase_country_code = v +i = ii +} + +9 { +res.has_license_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.license_type = v +i = ii +} + +10 { +res.has_territory_code = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.territory_code = v +i = ii +} + +11 { +res.has_change_number = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.change_number = v +i = ii +} + +12 { +res.has_owner_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.owner_id = v +i = ii +} + +13 { +res.has_initial_period = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.initial_period = v +i = ii +} + +14 { +res.has_initial_time_unit = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.initial_time_unit = v +i = ii +} + +15 { +res.has_renewal_period = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.renewal_period = v +i = ii +} + +16 { +res.has_renewal_time_unit = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.renewal_time_unit = v +i = ii +} + +17 { +res.has_access_token = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.access_token = v +i = ii +} + +18 { +res.has_master_package_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.master_package_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientlicenselistlicense() CMsgClientLicenseListLicense { +return CMsgClientLicenseListLicense{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientlicenselistlicense(o CMsgClientLicenseListLicense, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientlicenselistlicense(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientLicenseListLicense) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientlicenselistlicense_unpack(v)? +return i, unpacked +} +pub struct CMsgClientLicenseList { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +licenses []CMsgClientLicenseListLicense +} +pub fn (o &CMsgClientLicenseList) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +// [packed=false] +for _, x in o.licenses { +res << zzz_vproto_internal_pack_cmsgclientlicenselistlicense(x, 2) +} + +return res +} + +pub fn cmsgclientlicenselist_unpack(buf []byte) ?CMsgClientLicenseList { +mut res := CMsgClientLicenseList{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientlicenselistlicense(cur_buf, tag_wiretype.wire_type)? +res.licenses << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientlicenselist() CMsgClientLicenseList { +return CMsgClientLicenseList{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientlicenselist(o CMsgClientLicenseList, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientlicenselist(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientLicenseList) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientlicenselist_unpack(v)? +return i, unpacked +} +pub struct CMsgClientLBssetScore { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +leaderboard_id int +has_leaderboard_id bool +score int +has_score bool +details []byte +has_details bool +upload_score_method int +has_upload_score_method bool +} +pub fn (o &CMsgClientLBssetScore) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_leaderboard_id { +res << vproto.pack_int32_field(o.leaderboard_id, 2) +} + +if o.has_score { +res << vproto.pack_int32_field(o.score, 3) +} + +if o.has_details { +res << vproto.pack_bytes_field(o.details, 4) +} + +if o.has_upload_score_method { +res << vproto.pack_int32_field(o.upload_score_method, 5) +} + +return res +} + +pub fn cmsgclientlbssetscore_unpack(buf []byte) ?CMsgClientLBssetScore { +mut res := CMsgClientLBssetScore{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_leaderboard_id = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.leaderboard_id = v +i = ii +} + +3 { +res.has_score = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.score = v +i = ii +} + +4 { +res.has_details = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.details = v +i = ii +} + +5 { +res.has_upload_score_method = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.upload_score_method = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientlbssetscore() CMsgClientLBssetScore { +return CMsgClientLBssetScore{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientlbssetscore(o CMsgClientLBssetScore, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientlbssetscore(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientLBssetScore) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientlbssetscore_unpack(v)? +return i, unpacked +} +pub struct CMsgClientLBssetScoreResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +leaderboard_entry_count int +has_leaderboard_entry_count bool +score_changed bool +has_score_changed bool +global_rank_previous int +has_global_rank_previous bool +global_rank_new int +has_global_rank_new bool +} +pub fn (o &CMsgClientLBssetScoreResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_leaderboard_entry_count { +res << vproto.pack_int32_field(o.leaderboard_entry_count, 2) +} + +if o.has_score_changed { +res << vproto.pack_bool_field(o.score_changed, 3) +} + +if o.has_global_rank_previous { +res << vproto.pack_int32_field(o.global_rank_previous, 4) +} + +if o.has_global_rank_new { +res << vproto.pack_int32_field(o.global_rank_new, 5) +} + +return res +} + +pub fn cmsgclientlbssetscoreresponse_unpack(buf []byte) ?CMsgClientLBssetScoreResponse { +mut res := CMsgClientLBssetScoreResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_leaderboard_entry_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.leaderboard_entry_count = v +i = ii +} + +3 { +res.has_score_changed = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.score_changed = v +i = ii +} + +4 { +res.has_global_rank_previous = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.global_rank_previous = v +i = ii +} + +5 { +res.has_global_rank_new = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.global_rank_new = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientlbssetscoreresponse() CMsgClientLBssetScoreResponse { +return CMsgClientLBssetScoreResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientlbssetscoreresponse(o CMsgClientLBssetScoreResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientlbssetscoreresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientLBssetScoreResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientlbssetscoreresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientLBssetUGc { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +leaderboard_id int +has_leaderboard_id bool +ugc_id u64 +has_ugc_id bool +} +pub fn (o &CMsgClientLBssetUGc) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_leaderboard_id { +res << vproto.pack_int32_field(o.leaderboard_id, 2) +} + +if o.has_ugc_id { +res << vproto.pack_64bit_field(o.ugc_id, 3) +} + +return res +} + +pub fn cmsgclientlbssetugc_unpack(buf []byte) ?CMsgClientLBssetUGc { +mut res := CMsgClientLBssetUGc{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_leaderboard_id = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.leaderboard_id = v +i = ii +} + +3 { +res.has_ugc_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.ugc_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientlbssetugc() CMsgClientLBssetUGc { +return CMsgClientLBssetUGc{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientlbssetugc(o CMsgClientLBssetUGc, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientlbssetugc(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientLBssetUGc) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientlbssetugc_unpack(v)? +return i, unpacked +} +pub struct CMsgClientLBssetUGcresponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +} +pub fn (o &CMsgClientLBssetUGcresponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +return res +} + +pub fn cmsgclientlbssetugcresponse_unpack(buf []byte) ?CMsgClientLBssetUGcresponse { +mut res := CMsgClientLBssetUGcresponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientlbssetugcresponse() CMsgClientLBssetUGcresponse { +return CMsgClientLBssetUGcresponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientlbssetugcresponse(o CMsgClientLBssetUGcresponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientlbssetugcresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientLBssetUGcresponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientlbssetugcresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientLBsfindOrCreateLB { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +leaderboard_sort_method int +has_leaderboard_sort_method bool +leaderboard_display_type int +has_leaderboard_display_type bool +create_if_not_found bool +has_create_if_not_found bool +leaderboard_name string +has_leaderboard_name bool +} +pub fn (o &CMsgClientLBsfindOrCreateLB) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_leaderboard_sort_method { +res << vproto.pack_int32_field(o.leaderboard_sort_method, 2) +} + +if o.has_leaderboard_display_type { +res << vproto.pack_int32_field(o.leaderboard_display_type, 3) +} + +if o.has_create_if_not_found { +res << vproto.pack_bool_field(o.create_if_not_found, 4) +} + +if o.has_leaderboard_name { +res << vproto.pack_string_field(o.leaderboard_name, 5) +} + +return res +} + +pub fn cmsgclientlbsfindorcreatelb_unpack(buf []byte) ?CMsgClientLBsfindOrCreateLB { +mut res := CMsgClientLBsfindOrCreateLB{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_leaderboard_sort_method = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.leaderboard_sort_method = v +i = ii +} + +3 { +res.has_leaderboard_display_type = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.leaderboard_display_type = v +i = ii +} + +4 { +res.has_create_if_not_found = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.create_if_not_found = v +i = ii +} + +5 { +res.has_leaderboard_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.leaderboard_name = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientlbsfindorcreatelb() CMsgClientLBsfindOrCreateLB { +return CMsgClientLBsfindOrCreateLB{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientlbsfindorcreatelb(o CMsgClientLBsfindOrCreateLB, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientlbsfindorcreatelb(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientLBsfindOrCreateLB) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientlbsfindorcreatelb_unpack(v)? +return i, unpacked +} +pub struct CMsgClientLBsfindOrCreateLBresponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +leaderboard_id int +has_leaderboard_id bool +leaderboard_entry_count int +has_leaderboard_entry_count bool +leaderboard_sort_method int +has_leaderboard_sort_method bool +leaderboard_display_type int +has_leaderboard_display_type bool +leaderboard_name string +has_leaderboard_name bool +} +pub fn (o &CMsgClientLBsfindOrCreateLBresponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_leaderboard_id { +res << vproto.pack_int32_field(o.leaderboard_id, 2) +} + +if o.has_leaderboard_entry_count { +res << vproto.pack_int32_field(o.leaderboard_entry_count, 3) +} + +if o.has_leaderboard_sort_method { +res << vproto.pack_int32_field(o.leaderboard_sort_method, 4) +} + +if o.has_leaderboard_display_type { +res << vproto.pack_int32_field(o.leaderboard_display_type, 5) +} + +if o.has_leaderboard_name { +res << vproto.pack_string_field(o.leaderboard_name, 6) +} + +return res +} + +pub fn cmsgclientlbsfindorcreatelbresponse_unpack(buf []byte) ?CMsgClientLBsfindOrCreateLBresponse { +mut res := CMsgClientLBsfindOrCreateLBresponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_leaderboard_id = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.leaderboard_id = v +i = ii +} + +3 { +res.has_leaderboard_entry_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.leaderboard_entry_count = v +i = ii +} + +4 { +res.has_leaderboard_sort_method = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.leaderboard_sort_method = v +i = ii +} + +5 { +res.has_leaderboard_display_type = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.leaderboard_display_type = v +i = ii +} + +6 { +res.has_leaderboard_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.leaderboard_name = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientlbsfindorcreatelbresponse() CMsgClientLBsfindOrCreateLBresponse { +return CMsgClientLBsfindOrCreateLBresponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientlbsfindorcreatelbresponse(o CMsgClientLBsfindOrCreateLBresponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientlbsfindorcreatelbresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientLBsfindOrCreateLBresponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientlbsfindorcreatelbresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientLBsgetLBentries { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id int +has_app_id bool +leaderboard_id int +has_leaderboard_id bool +range_start int +has_range_start bool +range_end int +has_range_end bool +leaderboard_data_request int +has_leaderboard_data_request bool +steamids []u64 +} +pub fn (o &CMsgClientLBsgetLBentries) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_int32_field(o.app_id, 1) +} + +if o.has_leaderboard_id { +res << vproto.pack_int32_field(o.leaderboard_id, 2) +} + +if o.has_range_start { +res << vproto.pack_int32_field(o.range_start, 3) +} + +if o.has_range_end { +res << vproto.pack_int32_field(o.range_end, 4) +} + +if o.has_leaderboard_data_request { +res << vproto.pack_int32_field(o.leaderboard_data_request, 5) +} + +// [packed=false] +for _, x in o.steamids { +res << vproto.pack_64bit_field(x, 6) +} + +return res +} + +pub fn cmsgclientlbsgetlbentries_unpack(buf []byte) ?CMsgClientLBsgetLBentries { +mut res := CMsgClientLBsgetLBentries{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_leaderboard_id = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.leaderboard_id = v +i = ii +} + +3 { +res.has_range_start = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.range_start = v +i = ii +} + +4 { +res.has_range_end = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.range_end = v +i = ii +} + +5 { +res.has_leaderboard_data_request = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.leaderboard_data_request = v +i = ii +} + +6 { +// [packed=false] +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientlbsgetlbentries() CMsgClientLBsgetLBentries { +return CMsgClientLBsgetLBentries{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientlbsgetlbentries(o CMsgClientLBsgetLBentries, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientlbsgetlbentries(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientLBsgetLBentries) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientlbsgetlbentries_unpack(v)? +return i, unpacked +} +pub struct CMsgClientLBsgetLBentriesResponseEntry { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id_user u64 +has_steam_id_user bool +global_rank int +has_global_rank bool +score int +has_score bool +details []byte +has_details bool +ugc_id u64 +has_ugc_id bool +} +pub fn (o &CMsgClientLBsgetLBentriesResponseEntry) pack() []byte { +mut res := []byte{} +if o.has_steam_id_user { +res << vproto.pack_64bit_field(o.steam_id_user, 1) +} + +if o.has_global_rank { +res << vproto.pack_int32_field(o.global_rank, 2) +} + +if o.has_score { +res << vproto.pack_int32_field(o.score, 3) +} + +if o.has_details { +res << vproto.pack_bytes_field(o.details, 4) +} + +if o.has_ugc_id { +res << vproto.pack_64bit_field(o.ugc_id, 5) +} + +return res +} + +pub fn cmsgclientlbsgetlbentriesresponseentry_unpack(buf []byte) ?CMsgClientLBsgetLBentriesResponseEntry { +mut res := CMsgClientLBsgetLBentriesResponseEntry{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id_user = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_user = v +i = ii +} + +2 { +res.has_global_rank = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.global_rank = v +i = ii +} + +3 { +res.has_score = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.score = v +i = ii +} + +4 { +res.has_details = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.details = v +i = ii +} + +5 { +res.has_ugc_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.ugc_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientlbsgetlbentriesresponseentry() CMsgClientLBsgetLBentriesResponseEntry { +return CMsgClientLBsgetLBentriesResponseEntry{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientlbsgetlbentriesresponseentry(o CMsgClientLBsgetLBentriesResponseEntry, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientlbsgetlbentriesresponseentry(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientLBsgetLBentriesResponseEntry) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientlbsgetlbentriesresponseentry_unpack(v)? +return i, unpacked +} +pub struct CMsgClientLBsgetLBentriesResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +leaderboard_entry_count int +has_leaderboard_entry_count bool +entries []CMsgClientLBsgetLBentriesResponseEntry +} +pub fn (o &CMsgClientLBsgetLBentriesResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_leaderboard_entry_count { +res << vproto.pack_int32_field(o.leaderboard_entry_count, 2) +} + +// [packed=false] +for _, x in o.entries { +res << zzz_vproto_internal_pack_cmsgclientlbsgetlbentriesresponseentry(x, 3) +} + +return res +} + +pub fn cmsgclientlbsgetlbentriesresponse_unpack(buf []byte) ?CMsgClientLBsgetLBentriesResponse { +mut res := CMsgClientLBsgetLBentriesResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_leaderboard_entry_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.leaderboard_entry_count = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientlbsgetlbentriesresponseentry(cur_buf, tag_wiretype.wire_type)? +res.entries << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientlbsgetlbentriesresponse() CMsgClientLBsgetLBentriesResponse { +return CMsgClientLBsgetLBentriesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientlbsgetlbentriesresponse(o CMsgClientLBsgetLBentriesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientlbsgetlbentriesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientLBsgetLBentriesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientlbsgetlbentriesresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientAppMinutesPlayedDataAppMinutesPlayedData { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +forever int +has_forever bool +last_two_weeks int +has_last_two_weeks bool +} +pub fn (o &CMsgClientAppMinutesPlayedDataAppMinutesPlayedData) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_forever { +res << vproto.pack_int32_field(o.forever, 2) +} + +if o.has_last_two_weeks { +res << vproto.pack_int32_field(o.last_two_weeks, 3) +} + +return res +} + +pub fn cmsgclientappminutesplayeddataappminutesplayeddata_unpack(buf []byte) ?CMsgClientAppMinutesPlayedDataAppMinutesPlayedData { +mut res := CMsgClientAppMinutesPlayedDataAppMinutesPlayedData{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_forever = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.forever = v +i = ii +} + +3 { +res.has_last_two_weeks = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.last_two_weeks = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientappminutesplayeddataappminutesplayeddata() CMsgClientAppMinutesPlayedDataAppMinutesPlayedData { +return CMsgClientAppMinutesPlayedDataAppMinutesPlayedData{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientappminutesplayeddataappminutesplayeddata(o CMsgClientAppMinutesPlayedDataAppMinutesPlayedData, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientappminutesplayeddataappminutesplayeddata(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientAppMinutesPlayedDataAppMinutesPlayedData) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientappminutesplayeddataappminutesplayeddata_unpack(v)? +return i, unpacked +} +pub struct CMsgClientAppMinutesPlayedData { +mut: +unknown_fields []vproto.UnknownField +pub mut: +minutes_played []CMsgClientAppMinutesPlayedDataAppMinutesPlayedData +} +pub fn (o &CMsgClientAppMinutesPlayedData) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.minutes_played { +res << zzz_vproto_internal_pack_cmsgclientappminutesplayeddataappminutesplayeddata(x, 1) +} + +return res +} + +pub fn cmsgclientappminutesplayeddata_unpack(buf []byte) ?CMsgClientAppMinutesPlayedData { +mut res := CMsgClientAppMinutesPlayedData{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientappminutesplayeddataappminutesplayeddata(cur_buf, tag_wiretype.wire_type)? +res.minutes_played << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientappminutesplayeddata() CMsgClientAppMinutesPlayedData { +return CMsgClientAppMinutesPlayedData{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientappminutesplayeddata(o CMsgClientAppMinutesPlayedData, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientappminutesplayeddata(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientAppMinutesPlayedData) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientappminutesplayeddata_unpack(v)? +return i, unpacked +} +pub struct CMsgClientIsLimitedAccount { +mut: +unknown_fields []vproto.UnknownField +pub mut: +bis_limited_account bool +has_bis_limited_account bool +bis_community_banned bool +has_bis_community_banned bool +bis_locked_account bool +has_bis_locked_account bool +bis_limited_account_allowed_to_invite_friends bool +has_bis_limited_account_allowed_to_invite_friends bool +} +pub fn (o &CMsgClientIsLimitedAccount) pack() []byte { +mut res := []byte{} +if o.has_bis_limited_account { +res << vproto.pack_bool_field(o.bis_limited_account, 1) +} + +if o.has_bis_community_banned { +res << vproto.pack_bool_field(o.bis_community_banned, 2) +} + +if o.has_bis_locked_account { +res << vproto.pack_bool_field(o.bis_locked_account, 3) +} + +if o.has_bis_limited_account_allowed_to_invite_friends { +res << vproto.pack_bool_field(o.bis_limited_account_allowed_to_invite_friends, 4) +} + +return res +} + +pub fn cmsgclientislimitedaccount_unpack(buf []byte) ?CMsgClientIsLimitedAccount { +mut res := CMsgClientIsLimitedAccount{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_bis_limited_account = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.bis_limited_account = v +i = ii +} + +2 { +res.has_bis_community_banned = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.bis_community_banned = v +i = ii +} + +3 { +res.has_bis_locked_account = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.bis_locked_account = v +i = ii +} + +4 { +res.has_bis_limited_account_allowed_to_invite_friends = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.bis_limited_account_allowed_to_invite_friends = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientislimitedaccount() CMsgClientIsLimitedAccount { +return CMsgClientIsLimitedAccount{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientislimitedaccount(o CMsgClientIsLimitedAccount, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientislimitedaccount(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientIsLimitedAccount) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientislimitedaccount_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRequestedClientStatsStatsToSend { +mut: +unknown_fields []vproto.UnknownField +pub mut: +client_stat u32 +has_client_stat bool +stat_aggregate_method u32 +has_stat_aggregate_method bool +} +pub fn (o &CMsgClientRequestedClientStatsStatsToSend) pack() []byte { +mut res := []byte{} +if o.has_client_stat { +res << vproto.pack_uint32_field(o.client_stat, 1) +} + +if o.has_stat_aggregate_method { +res << vproto.pack_uint32_field(o.stat_aggregate_method, 2) +} + +return res +} + +pub fn cmsgclientrequestedclientstatsstatstosend_unpack(buf []byte) ?CMsgClientRequestedClientStatsStatsToSend { +mut res := CMsgClientRequestedClientStatsStatsToSend{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_client_stat = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.client_stat = v +i = ii +} + +2 { +res.has_stat_aggregate_method = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.stat_aggregate_method = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientrequestedclientstatsstatstosend() CMsgClientRequestedClientStatsStatsToSend { +return CMsgClientRequestedClientStatsStatsToSend{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientrequestedclientstatsstatstosend(o CMsgClientRequestedClientStatsStatsToSend, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientrequestedclientstatsstatstosend(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRequestedClientStatsStatsToSend) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientrequestedclientstatsstatstosend_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRequestedClientStats { +mut: +unknown_fields []vproto.UnknownField +pub mut: +stats_to_send []CMsgClientRequestedClientStatsStatsToSend +} +pub fn (o &CMsgClientRequestedClientStats) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.stats_to_send { +res << zzz_vproto_internal_pack_cmsgclientrequestedclientstatsstatstosend(x, 1) +} + +return res +} + +pub fn cmsgclientrequestedclientstats_unpack(buf []byte) ?CMsgClientRequestedClientStats { +mut res := CMsgClientRequestedClientStats{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientrequestedclientstatsstatstosend(cur_buf, tag_wiretype.wire_type)? +res.stats_to_send << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientrequestedclientstats() CMsgClientRequestedClientStats { +return CMsgClientRequestedClientStats{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientrequestedclientstats(o CMsgClientRequestedClientStats, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientrequestedclientstats(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRequestedClientStats) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientrequestedclientstats_unpack(v)? +return i, unpacked +} +pub struct CMsgClientStat2StatDetail { +mut: +unknown_fields []vproto.UnknownField +pub mut: +client_stat u32 +has_client_stat bool +ll_value i64 +has_ll_value bool +time_of_day u32 +has_time_of_day bool +cell_id u32 +has_cell_id bool +depot_id u32 +has_depot_id bool +app_id u32 +has_app_id bool +} +pub fn (o &CMsgClientStat2StatDetail) pack() []byte { +mut res := []byte{} +if o.has_client_stat { +res << vproto.pack_uint32_field(o.client_stat, 1) +} + +if o.has_ll_value { +res << vproto.pack_int64_field(o.ll_value, 2) +} + +if o.has_time_of_day { +res << vproto.pack_uint32_field(o.time_of_day, 3) +} + +if o.has_cell_id { +res << vproto.pack_uint32_field(o.cell_id, 4) +} + +if o.has_depot_id { +res << vproto.pack_uint32_field(o.depot_id, 5) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 6) +} + +return res +} + +pub fn cmsgclientstat2statdetail_unpack(buf []byte) ?CMsgClientStat2StatDetail { +mut res := CMsgClientStat2StatDetail{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_client_stat = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.client_stat = v +i = ii +} + +2 { +res.has_ll_value = true +ii, v := vproto.unpack_int64_field(cur_buf, tag_wiretype.wire_type)? +res.ll_value = v +i = ii +} + +3 { +res.has_time_of_day = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_of_day = v +i = ii +} + +4 { +res.has_cell_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cell_id = v +i = ii +} + +5 { +res.has_depot_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.depot_id = v +i = ii +} + +6 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientstat2statdetail() CMsgClientStat2StatDetail { +return CMsgClientStat2StatDetail{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientstat2statdetail(o CMsgClientStat2StatDetail, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientstat2statdetail(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientStat2StatDetail) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientstat2statdetail_unpack(v)? +return i, unpacked +} +pub struct CMsgClientStat2 { +mut: +unknown_fields []vproto.UnknownField +pub mut: +stat_detail []CMsgClientStat2StatDetail +} +pub fn (o &CMsgClientStat2) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.stat_detail { +res << zzz_vproto_internal_pack_cmsgclientstat2statdetail(x, 1) +} + +return res +} + +pub fn cmsgclientstat2_unpack(buf []byte) ?CMsgClientStat2 { +mut res := CMsgClientStat2{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientstat2statdetail(cur_buf, tag_wiretype.wire_type)? +res.stat_detail << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientstat2() CMsgClientStat2 { +return CMsgClientStat2{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientstat2(o CMsgClientStat2, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientstat2(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientStat2) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientstat2_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMssetRatelimitPolicyOnClient { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +enable_rate_limits bool +has_enable_rate_limits bool +seconds_per_message int +has_seconds_per_message bool +milliseconds_per_data_update int +has_milliseconds_per_data_update bool +} +pub fn (o &CMsgClientMMssetRatelimitPolicyOnClient) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_enable_rate_limits { +res << vproto.pack_bool_field(o.enable_rate_limits, 2) +} + +if o.has_seconds_per_message { +res << vproto.pack_int32_field(o.seconds_per_message, 3) +} + +if o.has_milliseconds_per_data_update { +res << vproto.pack_int32_field(o.milliseconds_per_data_update, 4) +} + +return res +} + +pub fn cmsgclientmmssetratelimitpolicyonclient_unpack(buf []byte) ?CMsgClientMMssetRatelimitPolicyOnClient { +mut res := CMsgClientMMssetRatelimitPolicyOnClient{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_enable_rate_limits = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enable_rate_limits = v +i = ii +} + +3 { +res.has_seconds_per_message = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_per_message = v +i = ii +} + +4 { +res.has_milliseconds_per_data_update = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.milliseconds_per_data_update = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmssetratelimitpolicyonclient() CMsgClientMMssetRatelimitPolicyOnClient { +return CMsgClientMMssetRatelimitPolicyOnClient{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmssetratelimitpolicyonclient(o CMsgClientMMssetRatelimitPolicyOnClient, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmssetratelimitpolicyonclient(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMssetRatelimitPolicyOnClient) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmssetratelimitpolicyonclient_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMscreateLobby { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +max_members int +has_max_members bool +lobby_type int +has_lobby_type bool +lobby_flags int +has_lobby_flags bool +cell_id u32 +has_cell_id bool +deprecated_public_ip u32 +has_deprecated_public_ip bool +metadata []byte +has_metadata bool +persona_name_owner string +has_persona_name_owner bool +public_ip CMsgIPaddress +has_public_ip bool +} +pub fn (o &CMsgClientMMscreateLobby) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_max_members { +res << vproto.pack_int32_field(o.max_members, 2) +} + +if o.has_lobby_type { +res << vproto.pack_int32_field(o.lobby_type, 3) +} + +if o.has_lobby_flags { +res << vproto.pack_int32_field(o.lobby_flags, 4) +} + +if o.has_cell_id { +res << vproto.pack_uint32_field(o.cell_id, 5) +} + +if o.has_deprecated_public_ip { +res << vproto.pack_uint32_field(o.deprecated_public_ip, 6) +} + +if o.has_metadata { +res << vproto.pack_bytes_field(o.metadata, 7) +} + +if o.has_persona_name_owner { +res << vproto.pack_string_field(o.persona_name_owner, 8) +} + +if o.has_public_ip { +res << zzz_vproto_internal_pack_cmsgipaddress(o.public_ip, 9) +} + +return res +} + +pub fn cmsgclientmmscreatelobby_unpack(buf []byte) ?CMsgClientMMscreateLobby { +mut res := CMsgClientMMscreateLobby{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_max_members = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.max_members = v +i = ii +} + +3 { +res.has_lobby_type = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.lobby_type = v +i = ii +} + +4 { +res.has_lobby_flags = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.lobby_flags = v +i = ii +} + +5 { +res.has_cell_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cell_id = v +i = ii +} + +6 { +res.has_deprecated_public_ip = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated_public_ip = v +i = ii +} + +7 { +res.has_metadata = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.metadata = v +i = ii +} + +8 { +res.has_persona_name_owner = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.persona_name_owner = v +i = ii +} + +9 { +res.has_public_ip = true +ii, v := zzz_vproto_internal_unpack_cmsgipaddress(cur_buf, tag_wiretype.wire_type)? +res.public_ip = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmscreatelobby() CMsgClientMMscreateLobby { +return CMsgClientMMscreateLobby{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmscreatelobby(o CMsgClientMMscreateLobby, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmscreatelobby(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMscreateLobby) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmscreatelobby_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMscreateLobbyResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +steam_id_lobby u64 +has_steam_id_lobby bool +eresult int +has_eresult bool +} +pub fn (o &CMsgClientMMscreateLobbyResponse) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_steam_id_lobby { +res << vproto.pack_64bit_field(o.steam_id_lobby, 2) +} + +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 3) +} + +return res +} + +pub fn cmsgclientmmscreatelobbyresponse_unpack(buf []byte) ?CMsgClientMMscreateLobbyResponse { +mut res := CMsgClientMMscreateLobbyResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_steam_id_lobby = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_lobby = v +i = ii +} + +3 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmscreatelobbyresponse() CMsgClientMMscreateLobbyResponse { +return CMsgClientMMscreateLobbyResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmscreatelobbyresponse(o CMsgClientMMscreateLobbyResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmscreatelobbyresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMscreateLobbyResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmscreatelobbyresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMsjoinLobby { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +steam_id_lobby u64 +has_steam_id_lobby bool +persona_name string +has_persona_name bool +} +pub fn (o &CMsgClientMMsjoinLobby) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_steam_id_lobby { +res << vproto.pack_64bit_field(o.steam_id_lobby, 2) +} + +if o.has_persona_name { +res << vproto.pack_string_field(o.persona_name, 3) +} + +return res +} + +pub fn cmsgclientmmsjoinlobby_unpack(buf []byte) ?CMsgClientMMsjoinLobby { +mut res := CMsgClientMMsjoinLobby{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_steam_id_lobby = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_lobby = v +i = ii +} + +3 { +res.has_persona_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.persona_name = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmsjoinlobby() CMsgClientMMsjoinLobby { +return CMsgClientMMsjoinLobby{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmsjoinlobby(o CMsgClientMMsjoinLobby, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmsjoinlobby(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMsjoinLobby) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmsjoinlobby_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMsjoinLobbyResponseMember { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id u64 +has_steam_id bool +persona_name string +has_persona_name bool +metadata []byte +has_metadata bool +} +pub fn (o &CMsgClientMMsjoinLobbyResponseMember) pack() []byte { +mut res := []byte{} +if o.has_steam_id { +res << vproto.pack_64bit_field(o.steam_id, 1) +} + +if o.has_persona_name { +res << vproto.pack_string_field(o.persona_name, 2) +} + +if o.has_metadata { +res << vproto.pack_bytes_field(o.metadata, 3) +} + +return res +} + +pub fn cmsgclientmmsjoinlobbyresponsemember_unpack(buf []byte) ?CMsgClientMMsjoinLobbyResponseMember { +mut res := CMsgClientMMsjoinLobbyResponseMember{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id = v +i = ii +} + +2 { +res.has_persona_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.persona_name = v +i = ii +} + +3 { +res.has_metadata = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.metadata = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmsjoinlobbyresponsemember() CMsgClientMMsjoinLobbyResponseMember { +return CMsgClientMMsjoinLobbyResponseMember{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmsjoinlobbyresponsemember(o CMsgClientMMsjoinLobbyResponseMember, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmsjoinlobbyresponsemember(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMsjoinLobbyResponseMember) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmsjoinlobbyresponsemember_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMsjoinLobbyResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +steam_id_lobby u64 +has_steam_id_lobby bool +chat_room_enter_response int +has_chat_room_enter_response bool +max_members int +has_max_members bool +lobby_type int +has_lobby_type bool +lobby_flags int +has_lobby_flags bool +steam_id_owner u64 +has_steam_id_owner bool +metadata []byte +has_metadata bool +members []CMsgClientMMsjoinLobbyResponseMember +} +pub fn (o &CMsgClientMMsjoinLobbyResponse) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_steam_id_lobby { +res << vproto.pack_64bit_field(o.steam_id_lobby, 2) +} + +if o.has_chat_room_enter_response { +res << vproto.pack_int32_field(o.chat_room_enter_response, 3) +} + +if o.has_max_members { +res << vproto.pack_int32_field(o.max_members, 4) +} + +if o.has_lobby_type { +res << vproto.pack_int32_field(o.lobby_type, 5) +} + +if o.has_lobby_flags { +res << vproto.pack_int32_field(o.lobby_flags, 6) +} + +if o.has_steam_id_owner { +res << vproto.pack_64bit_field(o.steam_id_owner, 7) +} + +if o.has_metadata { +res << vproto.pack_bytes_field(o.metadata, 8) +} + +// [packed=false] +for _, x in o.members { +res << zzz_vproto_internal_pack_cmsgclientmmsjoinlobbyresponsemember(x, 9) +} + +return res +} + +pub fn cmsgclientmmsjoinlobbyresponse_unpack(buf []byte) ?CMsgClientMMsjoinLobbyResponse { +mut res := CMsgClientMMsjoinLobbyResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_steam_id_lobby = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_lobby = v +i = ii +} + +3 { +res.has_chat_room_enter_response = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.chat_room_enter_response = v +i = ii +} + +4 { +res.has_max_members = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.max_members = v +i = ii +} + +5 { +res.has_lobby_type = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.lobby_type = v +i = ii +} + +6 { +res.has_lobby_flags = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.lobby_flags = v +i = ii +} + +7 { +res.has_steam_id_owner = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_owner = v +i = ii +} + +8 { +res.has_metadata = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.metadata = v +i = ii +} + +9 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientmmsjoinlobbyresponsemember(cur_buf, tag_wiretype.wire_type)? +res.members << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmsjoinlobbyresponse() CMsgClientMMsjoinLobbyResponse { +return CMsgClientMMsjoinLobbyResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmsjoinlobbyresponse(o CMsgClientMMsjoinLobbyResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmsjoinlobbyresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMsjoinLobbyResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmsjoinlobbyresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMsleaveLobby { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +steam_id_lobby u64 +has_steam_id_lobby bool +} +pub fn (o &CMsgClientMMsleaveLobby) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_steam_id_lobby { +res << vproto.pack_64bit_field(o.steam_id_lobby, 2) +} + +return res +} + +pub fn cmsgclientmmsleavelobby_unpack(buf []byte) ?CMsgClientMMsleaveLobby { +mut res := CMsgClientMMsleaveLobby{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_steam_id_lobby = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_lobby = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmsleavelobby() CMsgClientMMsleaveLobby { +return CMsgClientMMsleaveLobby{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmsleavelobby(o CMsgClientMMsleaveLobby, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmsleavelobby(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMsleaveLobby) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmsleavelobby_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMsleaveLobbyResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +steam_id_lobby u64 +has_steam_id_lobby bool +eresult int +has_eresult bool +} +pub fn (o &CMsgClientMMsleaveLobbyResponse) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_steam_id_lobby { +res << vproto.pack_64bit_field(o.steam_id_lobby, 2) +} + +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 3) +} + +return res +} + +pub fn cmsgclientmmsleavelobbyresponse_unpack(buf []byte) ?CMsgClientMMsleaveLobbyResponse { +mut res := CMsgClientMMsleaveLobbyResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_steam_id_lobby = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_lobby = v +i = ii +} + +3 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmsleavelobbyresponse() CMsgClientMMsleaveLobbyResponse { +return CMsgClientMMsleaveLobbyResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmsleavelobbyresponse(o CMsgClientMMsleaveLobbyResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmsleavelobbyresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMsleaveLobbyResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmsleavelobbyresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMsgetLobbyListFilter { +mut: +unknown_fields []vproto.UnknownField +pub mut: +key string +has_key bool +value string +has_value bool +comparision int +has_comparision bool +filter_type int +has_filter_type bool +} +pub fn (o &CMsgClientMMsgetLobbyListFilter) pack() []byte { +mut res := []byte{} +if o.has_key { +res << vproto.pack_string_field(o.key, 1) +} + +if o.has_value { +res << vproto.pack_string_field(o.value, 2) +} + +if o.has_comparision { +res << vproto.pack_int32_field(o.comparision, 3) +} + +if o.has_filter_type { +res << vproto.pack_int32_field(o.filter_type, 4) +} + +return res +} + +pub fn cmsgclientmmsgetlobbylistfilter_unpack(buf []byte) ?CMsgClientMMsgetLobbyListFilter { +mut res := CMsgClientMMsgetLobbyListFilter{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_key = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.key = v +i = ii +} + +2 { +res.has_value = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.value = v +i = ii +} + +3 { +res.has_comparision = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.comparision = v +i = ii +} + +4 { +res.has_filter_type = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.filter_type = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmsgetlobbylistfilter() CMsgClientMMsgetLobbyListFilter { +return CMsgClientMMsgetLobbyListFilter{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmsgetlobbylistfilter(o CMsgClientMMsgetLobbyListFilter, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmsgetlobbylistfilter(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMsgetLobbyListFilter) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmsgetlobbylistfilter_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMsgetLobbyList { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +num_lobbies_requested int +has_num_lobbies_requested bool +cell_id u32 +has_cell_id bool +deprecated_public_ip u32 +has_deprecated_public_ip bool +filters []CMsgClientMMsgetLobbyListFilter +public_ip CMsgIPaddress +has_public_ip bool +} +pub fn (o &CMsgClientMMsgetLobbyList) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_num_lobbies_requested { +res << vproto.pack_int32_field(o.num_lobbies_requested, 3) +} + +if o.has_cell_id { +res << vproto.pack_uint32_field(o.cell_id, 4) +} + +if o.has_deprecated_public_ip { +res << vproto.pack_uint32_field(o.deprecated_public_ip, 5) +} + +// [packed=false] +for _, x in o.filters { +res << zzz_vproto_internal_pack_cmsgclientmmsgetlobbylistfilter(x, 6) +} + +if o.has_public_ip { +res << zzz_vproto_internal_pack_cmsgipaddress(o.public_ip, 7) +} + +return res +} + +pub fn cmsgclientmmsgetlobbylist_unpack(buf []byte) ?CMsgClientMMsgetLobbyList { +mut res := CMsgClientMMsgetLobbyList{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +3 { +res.has_num_lobbies_requested = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.num_lobbies_requested = v +i = ii +} + +4 { +res.has_cell_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cell_id = v +i = ii +} + +5 { +res.has_deprecated_public_ip = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated_public_ip = v +i = ii +} + +6 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientmmsgetlobbylistfilter(cur_buf, tag_wiretype.wire_type)? +res.filters << v +i = ii +} + +7 { +res.has_public_ip = true +ii, v := zzz_vproto_internal_unpack_cmsgipaddress(cur_buf, tag_wiretype.wire_type)? +res.public_ip = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmsgetlobbylist() CMsgClientMMsgetLobbyList { +return CMsgClientMMsgetLobbyList{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmsgetlobbylist(o CMsgClientMMsgetLobbyList, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmsgetlobbylist(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMsgetLobbyList) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmsgetlobbylist_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMsgetLobbyListResponseLobby { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id u64 +has_steam_id bool +max_members int +has_max_members bool +lobby_type int +has_lobby_type bool +lobby_flags int +has_lobby_flags bool +metadata []byte +has_metadata bool +num_members int +has_num_members bool +distance f32 +has_distance bool +weight i64 +has_weight bool +} +pub fn (o &CMsgClientMMsgetLobbyListResponseLobby) pack() []byte { +mut res := []byte{} +if o.has_steam_id { +res << vproto.pack_64bit_field(o.steam_id, 1) +} + +if o.has_max_members { +res << vproto.pack_int32_field(o.max_members, 2) +} + +if o.has_lobby_type { +res << vproto.pack_int32_field(o.lobby_type, 3) +} + +if o.has_lobby_flags { +res << vproto.pack_int32_field(o.lobby_flags, 4) +} + +if o.has_metadata { +res << vproto.pack_bytes_field(o.metadata, 5) +} + +if o.has_num_members { +res << vproto.pack_int32_field(o.num_members, 6) +} + +if o.has_distance { +res << vproto.pack_float_field(o.distance, 7) +} + +if o.has_weight { +res << vproto.pack_int64_field(o.weight, 8) +} + +return res +} + +pub fn cmsgclientmmsgetlobbylistresponselobby_unpack(buf []byte) ?CMsgClientMMsgetLobbyListResponseLobby { +mut res := CMsgClientMMsgetLobbyListResponseLobby{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id = v +i = ii +} + +2 { +res.has_max_members = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.max_members = v +i = ii +} + +3 { +res.has_lobby_type = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.lobby_type = v +i = ii +} + +4 { +res.has_lobby_flags = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.lobby_flags = v +i = ii +} + +5 { +res.has_metadata = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.metadata = v +i = ii +} + +6 { +res.has_num_members = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.num_members = v +i = ii +} + +7 { +res.has_distance = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.distance = v +i = ii +} + +8 { +res.has_weight = true +ii, v := vproto.unpack_int64_field(cur_buf, tag_wiretype.wire_type)? +res.weight = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmsgetlobbylistresponselobby() CMsgClientMMsgetLobbyListResponseLobby { +return CMsgClientMMsgetLobbyListResponseLobby{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmsgetlobbylistresponselobby(o CMsgClientMMsgetLobbyListResponseLobby, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmsgetlobbylistresponselobby(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMsgetLobbyListResponseLobby) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmsgetlobbylistresponselobby_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMsgetLobbyListResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +eresult int +has_eresult bool +lobbies []CMsgClientMMsgetLobbyListResponseLobby +} +pub fn (o &CMsgClientMMsgetLobbyListResponse) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 3) +} + +// [packed=false] +for _, x in o.lobbies { +res << zzz_vproto_internal_pack_cmsgclientmmsgetlobbylistresponselobby(x, 4) +} + +return res +} + +pub fn cmsgclientmmsgetlobbylistresponse_unpack(buf []byte) ?CMsgClientMMsgetLobbyListResponse { +mut res := CMsgClientMMsgetLobbyListResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +3 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientmmsgetlobbylistresponselobby(cur_buf, tag_wiretype.wire_type)? +res.lobbies << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmsgetlobbylistresponse() CMsgClientMMsgetLobbyListResponse { +return CMsgClientMMsgetLobbyListResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmsgetlobbylistresponse(o CMsgClientMMsgetLobbyListResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmsgetlobbylistresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMsgetLobbyListResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmsgetlobbylistresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMssetLobbyData { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +steam_id_lobby u64 +has_steam_id_lobby bool +steam_id_member u64 +has_steam_id_member bool +max_members int +has_max_members bool +lobby_type int +has_lobby_type bool +lobby_flags int +has_lobby_flags bool +metadata []byte +has_metadata bool +} +pub fn (o &CMsgClientMMssetLobbyData) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_steam_id_lobby { +res << vproto.pack_64bit_field(o.steam_id_lobby, 2) +} + +if o.has_steam_id_member { +res << vproto.pack_64bit_field(o.steam_id_member, 3) +} + +if o.has_max_members { +res << vproto.pack_int32_field(o.max_members, 4) +} + +if o.has_lobby_type { +res << vproto.pack_int32_field(o.lobby_type, 5) +} + +if o.has_lobby_flags { +res << vproto.pack_int32_field(o.lobby_flags, 6) +} + +if o.has_metadata { +res << vproto.pack_bytes_field(o.metadata, 7) +} + +return res +} + +pub fn cmsgclientmmssetlobbydata_unpack(buf []byte) ?CMsgClientMMssetLobbyData { +mut res := CMsgClientMMssetLobbyData{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_steam_id_lobby = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_lobby = v +i = ii +} + +3 { +res.has_steam_id_member = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_member = v +i = ii +} + +4 { +res.has_max_members = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.max_members = v +i = ii +} + +5 { +res.has_lobby_type = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.lobby_type = v +i = ii +} + +6 { +res.has_lobby_flags = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.lobby_flags = v +i = ii +} + +7 { +res.has_metadata = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.metadata = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmssetlobbydata() CMsgClientMMssetLobbyData { +return CMsgClientMMssetLobbyData{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmssetlobbydata(o CMsgClientMMssetLobbyData, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmssetlobbydata(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMssetLobbyData) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmssetlobbydata_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMssetLobbyDataResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +steam_id_lobby u64 +has_steam_id_lobby bool +eresult int +has_eresult bool +} +pub fn (o &CMsgClientMMssetLobbyDataResponse) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_steam_id_lobby { +res << vproto.pack_64bit_field(o.steam_id_lobby, 2) +} + +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 3) +} + +return res +} + +pub fn cmsgclientmmssetlobbydataresponse_unpack(buf []byte) ?CMsgClientMMssetLobbyDataResponse { +mut res := CMsgClientMMssetLobbyDataResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_steam_id_lobby = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_lobby = v +i = ii +} + +3 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmssetlobbydataresponse() CMsgClientMMssetLobbyDataResponse { +return CMsgClientMMssetLobbyDataResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmssetlobbydataresponse(o CMsgClientMMssetLobbyDataResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmssetlobbydataresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMssetLobbyDataResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmssetlobbydataresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMsgetLobbyData { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +steam_id_lobby u64 +has_steam_id_lobby bool +} +pub fn (o &CMsgClientMMsgetLobbyData) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_steam_id_lobby { +res << vproto.pack_64bit_field(o.steam_id_lobby, 2) +} + +return res +} + +pub fn cmsgclientmmsgetlobbydata_unpack(buf []byte) ?CMsgClientMMsgetLobbyData { +mut res := CMsgClientMMsgetLobbyData{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_steam_id_lobby = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_lobby = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmsgetlobbydata() CMsgClientMMsgetLobbyData { +return CMsgClientMMsgetLobbyData{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmsgetlobbydata(o CMsgClientMMsgetLobbyData, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmsgetlobbydata(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMsgetLobbyData) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmsgetlobbydata_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMslobbyDataMember { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id u64 +has_steam_id bool +persona_name string +has_persona_name bool +metadata []byte +has_metadata bool +} +pub fn (o &CMsgClientMMslobbyDataMember) pack() []byte { +mut res := []byte{} +if o.has_steam_id { +res << vproto.pack_64bit_field(o.steam_id, 1) +} + +if o.has_persona_name { +res << vproto.pack_string_field(o.persona_name, 2) +} + +if o.has_metadata { +res << vproto.pack_bytes_field(o.metadata, 3) +} + +return res +} + +pub fn cmsgclientmmslobbydatamember_unpack(buf []byte) ?CMsgClientMMslobbyDataMember { +mut res := CMsgClientMMslobbyDataMember{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id = v +i = ii +} + +2 { +res.has_persona_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.persona_name = v +i = ii +} + +3 { +res.has_metadata = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.metadata = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmslobbydatamember() CMsgClientMMslobbyDataMember { +return CMsgClientMMslobbyDataMember{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmslobbydatamember(o CMsgClientMMslobbyDataMember, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmslobbydatamember(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMslobbyDataMember) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmslobbydatamember_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMslobbyData { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +steam_id_lobby u64 +has_steam_id_lobby bool +num_members int +has_num_members bool +max_members int +has_max_members bool +lobby_type int +has_lobby_type bool +lobby_flags int +has_lobby_flags bool +steam_id_owner u64 +has_steam_id_owner bool +metadata []byte +has_metadata bool +members []CMsgClientMMslobbyDataMember +lobby_cellid u32 +has_lobby_cellid bool +owner_should_accept_changes bool +has_owner_should_accept_changes bool +} +pub fn (o &CMsgClientMMslobbyData) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_steam_id_lobby { +res << vproto.pack_64bit_field(o.steam_id_lobby, 2) +} + +if o.has_num_members { +res << vproto.pack_int32_field(o.num_members, 3) +} + +if o.has_max_members { +res << vproto.pack_int32_field(o.max_members, 4) +} + +if o.has_lobby_type { +res << vproto.pack_int32_field(o.lobby_type, 5) +} + +if o.has_lobby_flags { +res << vproto.pack_int32_field(o.lobby_flags, 6) +} + +if o.has_steam_id_owner { +res << vproto.pack_64bit_field(o.steam_id_owner, 7) +} + +if o.has_metadata { +res << vproto.pack_bytes_field(o.metadata, 8) +} + +// [packed=false] +for _, x in o.members { +res << zzz_vproto_internal_pack_cmsgclientmmslobbydatamember(x, 9) +} + +if o.has_lobby_cellid { +res << vproto.pack_uint32_field(o.lobby_cellid, 10) +} + +if o.has_owner_should_accept_changes { +res << vproto.pack_bool_field(o.owner_should_accept_changes, 11) +} + +return res +} + +pub fn cmsgclientmmslobbydata_unpack(buf []byte) ?CMsgClientMMslobbyData { +mut res := CMsgClientMMslobbyData{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_steam_id_lobby = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_lobby = v +i = ii +} + +3 { +res.has_num_members = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.num_members = v +i = ii +} + +4 { +res.has_max_members = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.max_members = v +i = ii +} + +5 { +res.has_lobby_type = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.lobby_type = v +i = ii +} + +6 { +res.has_lobby_flags = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.lobby_flags = v +i = ii +} + +7 { +res.has_steam_id_owner = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_owner = v +i = ii +} + +8 { +res.has_metadata = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.metadata = v +i = ii +} + +9 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientmmslobbydatamember(cur_buf, tag_wiretype.wire_type)? +res.members << v +i = ii +} + +10 { +res.has_lobby_cellid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.lobby_cellid = v +i = ii +} + +11 { +res.has_owner_should_accept_changes = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.owner_should_accept_changes = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmslobbydata() CMsgClientMMslobbyData { +return CMsgClientMMslobbyData{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmslobbydata(o CMsgClientMMslobbyData, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmslobbydata(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMslobbyData) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmslobbydata_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMssendLobbyChatMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +steam_id_lobby u64 +has_steam_id_lobby bool +steam_id_target u64 +has_steam_id_target bool +lobby_message []byte +has_lobby_message bool +} +pub fn (o &CMsgClientMMssendLobbyChatMsg) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_steam_id_lobby { +res << vproto.pack_64bit_field(o.steam_id_lobby, 2) +} + +if o.has_steam_id_target { +res << vproto.pack_64bit_field(o.steam_id_target, 3) +} + +if o.has_lobby_message { +res << vproto.pack_bytes_field(o.lobby_message, 4) +} + +return res +} + +pub fn cmsgclientmmssendlobbychatmsg_unpack(buf []byte) ?CMsgClientMMssendLobbyChatMsg { +mut res := CMsgClientMMssendLobbyChatMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_steam_id_lobby = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_lobby = v +i = ii +} + +3 { +res.has_steam_id_target = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_target = v +i = ii +} + +4 { +res.has_lobby_message = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.lobby_message = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmssendlobbychatmsg() CMsgClientMMssendLobbyChatMsg { +return CMsgClientMMssendLobbyChatMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmssendlobbychatmsg(o CMsgClientMMssendLobbyChatMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmssendlobbychatmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMssendLobbyChatMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmssendlobbychatmsg_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMslobbyChatMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +steam_id_lobby u64 +has_steam_id_lobby bool +steam_id_sender u64 +has_steam_id_sender bool +lobby_message []byte +has_lobby_message bool +} +pub fn (o &CMsgClientMMslobbyChatMsg) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_steam_id_lobby { +res << vproto.pack_64bit_field(o.steam_id_lobby, 2) +} + +if o.has_steam_id_sender { +res << vproto.pack_64bit_field(o.steam_id_sender, 3) +} + +if o.has_lobby_message { +res << vproto.pack_bytes_field(o.lobby_message, 4) +} + +return res +} + +pub fn cmsgclientmmslobbychatmsg_unpack(buf []byte) ?CMsgClientMMslobbyChatMsg { +mut res := CMsgClientMMslobbyChatMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_steam_id_lobby = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_lobby = v +i = ii +} + +3 { +res.has_steam_id_sender = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_sender = v +i = ii +} + +4 { +res.has_lobby_message = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.lobby_message = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmslobbychatmsg() CMsgClientMMslobbyChatMsg { +return CMsgClientMMslobbyChatMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmslobbychatmsg(o CMsgClientMMslobbyChatMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmslobbychatmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMslobbyChatMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmslobbychatmsg_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMssetLobbyOwner { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +steam_id_lobby u64 +has_steam_id_lobby bool +steam_id_new_owner u64 +has_steam_id_new_owner bool +} +pub fn (o &CMsgClientMMssetLobbyOwner) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_steam_id_lobby { +res << vproto.pack_64bit_field(o.steam_id_lobby, 2) +} + +if o.has_steam_id_new_owner { +res << vproto.pack_64bit_field(o.steam_id_new_owner, 3) +} + +return res +} + +pub fn cmsgclientmmssetlobbyowner_unpack(buf []byte) ?CMsgClientMMssetLobbyOwner { +mut res := CMsgClientMMssetLobbyOwner{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_steam_id_lobby = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_lobby = v +i = ii +} + +3 { +res.has_steam_id_new_owner = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_new_owner = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmssetlobbyowner() CMsgClientMMssetLobbyOwner { +return CMsgClientMMssetLobbyOwner{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmssetlobbyowner(o CMsgClientMMssetLobbyOwner, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmssetlobbyowner(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMssetLobbyOwner) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmssetlobbyowner_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMssetLobbyOwnerResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +steam_id_lobby u64 +has_steam_id_lobby bool +eresult int +has_eresult bool +} +pub fn (o &CMsgClientMMssetLobbyOwnerResponse) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_steam_id_lobby { +res << vproto.pack_64bit_field(o.steam_id_lobby, 2) +} + +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 3) +} + +return res +} + +pub fn cmsgclientmmssetlobbyownerresponse_unpack(buf []byte) ?CMsgClientMMssetLobbyOwnerResponse { +mut res := CMsgClientMMssetLobbyOwnerResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_steam_id_lobby = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_lobby = v +i = ii +} + +3 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmssetlobbyownerresponse() CMsgClientMMssetLobbyOwnerResponse { +return CMsgClientMMssetLobbyOwnerResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmssetlobbyownerresponse(o CMsgClientMMssetLobbyOwnerResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmssetlobbyownerresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMssetLobbyOwnerResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmssetlobbyownerresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMssetLobbyLinked { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +steam_id_lobby u64 +has_steam_id_lobby bool +steam_id_lobby2 u64 +has_steam_id_lobby2 bool +} +pub fn (o &CMsgClientMMssetLobbyLinked) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_steam_id_lobby { +res << vproto.pack_64bit_field(o.steam_id_lobby, 2) +} + +if o.has_steam_id_lobby2 { +res << vproto.pack_64bit_field(o.steam_id_lobby2, 3) +} + +return res +} + +pub fn cmsgclientmmssetlobbylinked_unpack(buf []byte) ?CMsgClientMMssetLobbyLinked { +mut res := CMsgClientMMssetLobbyLinked{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_steam_id_lobby = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_lobby = v +i = ii +} + +3 { +res.has_steam_id_lobby2 = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_lobby2 = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmssetlobbylinked() CMsgClientMMssetLobbyLinked { +return CMsgClientMMssetLobbyLinked{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmssetlobbylinked(o CMsgClientMMssetLobbyLinked, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmssetlobbylinked(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMssetLobbyLinked) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmssetlobbylinked_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMssetLobbyGameServer { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +steam_id_lobby u64 +has_steam_id_lobby bool +deprecated_game_server_ip u32 +has_deprecated_game_server_ip bool +game_server_port u32 +has_game_server_port bool +game_server_steam_id u64 +has_game_server_steam_id bool +game_server_ip CMsgIPaddress +has_game_server_ip bool +} +pub fn (o &CMsgClientMMssetLobbyGameServer) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_steam_id_lobby { +res << vproto.pack_64bit_field(o.steam_id_lobby, 2) +} + +if o.has_deprecated_game_server_ip { +res << vproto.pack_uint32_field(o.deprecated_game_server_ip, 3) +} + +if o.has_game_server_port { +res << vproto.pack_uint32_field(o.game_server_port, 4) +} + +if o.has_game_server_steam_id { +res << vproto.pack_64bit_field(o.game_server_steam_id, 5) +} + +if o.has_game_server_ip { +res << zzz_vproto_internal_pack_cmsgipaddress(o.game_server_ip, 6) +} + +return res +} + +pub fn cmsgclientmmssetlobbygameserver_unpack(buf []byte) ?CMsgClientMMssetLobbyGameServer { +mut res := CMsgClientMMssetLobbyGameServer{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_steam_id_lobby = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_lobby = v +i = ii +} + +3 { +res.has_deprecated_game_server_ip = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated_game_server_ip = v +i = ii +} + +4 { +res.has_game_server_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.game_server_port = v +i = ii +} + +5 { +res.has_game_server_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.game_server_steam_id = v +i = ii +} + +6 { +res.has_game_server_ip = true +ii, v := zzz_vproto_internal_unpack_cmsgipaddress(cur_buf, tag_wiretype.wire_type)? +res.game_server_ip = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmssetlobbygameserver() CMsgClientMMssetLobbyGameServer { +return CMsgClientMMssetLobbyGameServer{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmssetlobbygameserver(o CMsgClientMMssetLobbyGameServer, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmssetlobbygameserver(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMssetLobbyGameServer) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmssetlobbygameserver_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMslobbyGameServerSet { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +steam_id_lobby u64 +has_steam_id_lobby bool +deprecated_game_server_ip u32 +has_deprecated_game_server_ip bool +game_server_port u32 +has_game_server_port bool +game_server_steam_id u64 +has_game_server_steam_id bool +game_server_ip CMsgIPaddress +has_game_server_ip bool +} +pub fn (o &CMsgClientMMslobbyGameServerSet) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_steam_id_lobby { +res << vproto.pack_64bit_field(o.steam_id_lobby, 2) +} + +if o.has_deprecated_game_server_ip { +res << vproto.pack_uint32_field(o.deprecated_game_server_ip, 3) +} + +if o.has_game_server_port { +res << vproto.pack_uint32_field(o.game_server_port, 4) +} + +if o.has_game_server_steam_id { +res << vproto.pack_64bit_field(o.game_server_steam_id, 5) +} + +if o.has_game_server_ip { +res << zzz_vproto_internal_pack_cmsgipaddress(o.game_server_ip, 6) +} + +return res +} + +pub fn cmsgclientmmslobbygameserverset_unpack(buf []byte) ?CMsgClientMMslobbyGameServerSet { +mut res := CMsgClientMMslobbyGameServerSet{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_steam_id_lobby = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_lobby = v +i = ii +} + +3 { +res.has_deprecated_game_server_ip = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated_game_server_ip = v +i = ii +} + +4 { +res.has_game_server_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.game_server_port = v +i = ii +} + +5 { +res.has_game_server_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.game_server_steam_id = v +i = ii +} + +6 { +res.has_game_server_ip = true +ii, v := zzz_vproto_internal_unpack_cmsgipaddress(cur_buf, tag_wiretype.wire_type)? +res.game_server_ip = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmslobbygameserverset() CMsgClientMMslobbyGameServerSet { +return CMsgClientMMslobbyGameServerSet{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmslobbygameserverset(o CMsgClientMMslobbyGameServerSet, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmslobbygameserverset(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMslobbyGameServerSet) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmslobbygameserverset_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMsuserJoinedLobby { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +steam_id_lobby u64 +has_steam_id_lobby bool +steam_id_user u64 +has_steam_id_user bool +persona_name string +has_persona_name bool +} +pub fn (o &CMsgClientMMsuserJoinedLobby) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_steam_id_lobby { +res << vproto.pack_64bit_field(o.steam_id_lobby, 2) +} + +if o.has_steam_id_user { +res << vproto.pack_64bit_field(o.steam_id_user, 3) +} + +if o.has_persona_name { +res << vproto.pack_string_field(o.persona_name, 4) +} + +return res +} + +pub fn cmsgclientmmsuserjoinedlobby_unpack(buf []byte) ?CMsgClientMMsuserJoinedLobby { +mut res := CMsgClientMMsuserJoinedLobby{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_steam_id_lobby = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_lobby = v +i = ii +} + +3 { +res.has_steam_id_user = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_user = v +i = ii +} + +4 { +res.has_persona_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.persona_name = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmsuserjoinedlobby() CMsgClientMMsuserJoinedLobby { +return CMsgClientMMsuserJoinedLobby{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmsuserjoinedlobby(o CMsgClientMMsuserJoinedLobby, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmsuserjoinedlobby(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMsuserJoinedLobby) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmsuserjoinedlobby_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMsuserLeftLobby { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +steam_id_lobby u64 +has_steam_id_lobby bool +steam_id_user u64 +has_steam_id_user bool +persona_name string +has_persona_name bool +} +pub fn (o &CMsgClientMMsuserLeftLobby) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_steam_id_lobby { +res << vproto.pack_64bit_field(o.steam_id_lobby, 2) +} + +if o.has_steam_id_user { +res << vproto.pack_64bit_field(o.steam_id_user, 3) +} + +if o.has_persona_name { +res << vproto.pack_string_field(o.persona_name, 4) +} + +return res +} + +pub fn cmsgclientmmsuserleftlobby_unpack(buf []byte) ?CMsgClientMMsuserLeftLobby { +mut res := CMsgClientMMsuserLeftLobby{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_steam_id_lobby = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_lobby = v +i = ii +} + +3 { +res.has_steam_id_user = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_user = v +i = ii +} + +4 { +res.has_persona_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.persona_name = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmsuserleftlobby() CMsgClientMMsuserLeftLobby { +return CMsgClientMMsuserLeftLobby{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmsuserleftlobby(o CMsgClientMMsuserLeftLobby, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmsuserleftlobby(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMsuserLeftLobby) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmsuserleftlobby_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMsinviteToLobby { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +steam_id_lobby u64 +has_steam_id_lobby bool +steam_id_user_invited u64 +has_steam_id_user_invited bool +} +pub fn (o &CMsgClientMMsinviteToLobby) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_steam_id_lobby { +res << vproto.pack_64bit_field(o.steam_id_lobby, 2) +} + +if o.has_steam_id_user_invited { +res << vproto.pack_64bit_field(o.steam_id_user_invited, 3) +} + +return res +} + +pub fn cmsgclientmmsinvitetolobby_unpack(buf []byte) ?CMsgClientMMsinviteToLobby { +mut res := CMsgClientMMsinviteToLobby{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_steam_id_lobby = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_lobby = v +i = ii +} + +3 { +res.has_steam_id_user_invited = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_user_invited = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmsinvitetolobby() CMsgClientMMsinviteToLobby { +return CMsgClientMMsinviteToLobby{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmsinvitetolobby(o CMsgClientMMsinviteToLobby, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmsinvitetolobby(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMsinviteToLobby) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmsinvitetolobby_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMsgetLobbyStatus { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +steam_id_lobby u64 +has_steam_id_lobby bool +claim_membership bool +has_claim_membership bool +claim_ownership bool +has_claim_ownership bool +} +pub fn (o &CMsgClientMMsgetLobbyStatus) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_steam_id_lobby { +res << vproto.pack_64bit_field(o.steam_id_lobby, 2) +} + +if o.has_claim_membership { +res << vproto.pack_bool_field(o.claim_membership, 3) +} + +if o.has_claim_ownership { +res << vproto.pack_bool_field(o.claim_ownership, 4) +} + +return res +} + +pub fn cmsgclientmmsgetlobbystatus_unpack(buf []byte) ?CMsgClientMMsgetLobbyStatus { +mut res := CMsgClientMMsgetLobbyStatus{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_steam_id_lobby = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_lobby = v +i = ii +} + +3 { +res.has_claim_membership = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.claim_membership = v +i = ii +} + +4 { +res.has_claim_ownership = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.claim_ownership = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmsgetlobbystatus() CMsgClientMMsgetLobbyStatus { +return CMsgClientMMsgetLobbyStatus{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmsgetlobbystatus(o CMsgClientMMsgetLobbyStatus, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmsgetlobbystatus(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMsgetLobbyStatus) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmsgetlobbystatus_unpack(v)? +return i, unpacked +} +pub struct CMsgClientMMsgetLobbyStatusResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +steam_id_lobby u64 +has_steam_id_lobby bool +lobby_status EMmslobbyStatus +has_lobby_status bool +} +pub fn (o &CMsgClientMMsgetLobbyStatusResponse) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_steam_id_lobby { +res << vproto.pack_64bit_field(o.steam_id_lobby, 2) +} + +if o.has_lobby_status { +res << zzz_vproto_internal_pack_emmslobbystatus(o.lobby_status, 3) +} + +return res +} + +pub fn cmsgclientmmsgetlobbystatusresponse_unpack(buf []byte) ?CMsgClientMMsgetLobbyStatusResponse { +mut res := CMsgClientMMsgetLobbyStatusResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_steam_id_lobby = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_lobby = v +i = ii +} + +3 { +res.has_lobby_status = true +ii, v := zzz_vproto_internal_unpack_emmslobbystatus(cur_buf, tag_wiretype.wire_type)? +res.lobby_status = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientmmsgetlobbystatusresponse() CMsgClientMMsgetLobbyStatusResponse { +return CMsgClientMMsgetLobbyStatusResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientmmsgetlobbystatusresponse(o CMsgClientMMsgetLobbyStatusResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientmmsgetlobbystatusresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientMMsgetLobbyStatusResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientmmsgetlobbystatusresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientInviteToGame { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id_dest u64 +has_steam_id_dest bool +steam_id_src u64 +has_steam_id_src bool +connect_string string +has_connect_string bool +remote_play string +has_remote_play bool +} +pub fn (o &CMsgClientInviteToGame) pack() []byte { +mut res := []byte{} +if o.has_steam_id_dest { +res << vproto.pack_64bit_field(o.steam_id_dest, 1) +} + +if o.has_steam_id_src { +res << vproto.pack_64bit_field(o.steam_id_src, 2) +} + +if o.has_connect_string { +res << vproto.pack_string_field(o.connect_string, 3) +} + +if o.has_remote_play { +res << vproto.pack_string_field(o.remote_play, 4) +} + +return res +} + +pub fn cmsgclientinvitetogame_unpack(buf []byte) ?CMsgClientInviteToGame { +mut res := CMsgClientInviteToGame{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id_dest = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_dest = v +i = ii +} + +2 { +res.has_steam_id_src = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_src = v +i = ii +} + +3 { +res.has_connect_string = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.connect_string = v +i = ii +} + +4 { +res.has_remote_play = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.remote_play = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientinvitetogame() CMsgClientInviteToGame { +return CMsgClientInviteToGame{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientinvitetogame(o CMsgClientInviteToGame, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientinvitetogame(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientInviteToGame) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientinvitetogame_unpack(v)? +return i, unpacked +} +pub struct CMsgClientChatInvite { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id_invited u64 +has_steam_id_invited bool +steam_id_chat u64 +has_steam_id_chat bool +steam_id_patron u64 +has_steam_id_patron bool +chatroom_type int +has_chatroom_type bool +steam_id_friend_chat u64 +has_steam_id_friend_chat bool +chat_name string +has_chat_name bool +game_id u64 +has_game_id bool +} +pub fn (o &CMsgClientChatInvite) pack() []byte { +mut res := []byte{} +if o.has_steam_id_invited { +res << vproto.pack_64bit_field(o.steam_id_invited, 1) +} + +if o.has_steam_id_chat { +res << vproto.pack_64bit_field(o.steam_id_chat, 2) +} + +if o.has_steam_id_patron { +res << vproto.pack_64bit_field(o.steam_id_patron, 3) +} + +if o.has_chatroom_type { +res << vproto.pack_int32_field(o.chatroom_type, 4) +} + +if o.has_steam_id_friend_chat { +res << vproto.pack_64bit_field(o.steam_id_friend_chat, 5) +} + +if o.has_chat_name { +res << vproto.pack_string_field(o.chat_name, 6) +} + +if o.has_game_id { +res << vproto.pack_64bit_field(o.game_id, 7) +} + +return res +} + +pub fn cmsgclientchatinvite_unpack(buf []byte) ?CMsgClientChatInvite { +mut res := CMsgClientChatInvite{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id_invited = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_invited = v +i = ii +} + +2 { +res.has_steam_id_chat = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_chat = v +i = ii +} + +3 { +res.has_steam_id_patron = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_patron = v +i = ii +} + +4 { +res.has_chatroom_type = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.chatroom_type = v +i = ii +} + +5 { +res.has_steam_id_friend_chat = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_friend_chat = v +i = ii +} + +6 { +res.has_chat_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.chat_name = v +i = ii +} + +7 { +res.has_game_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.game_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientchatinvite() CMsgClientChatInvite { +return CMsgClientChatInvite{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientchatinvite(o CMsgClientChatInvite, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientchatinvite(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientChatInvite) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientchatinvite_unpack(v)? +return i, unpacked +} +pub struct CMsgClientConnectionStatsStatsLogon { +mut: +unknown_fields []vproto.UnknownField +pub mut: +connect_attempts int +has_connect_attempts bool +connect_successes int +has_connect_successes bool +connect_failures int +has_connect_failures bool +connections_dropped int +has_connections_dropped bool +seconds_running u32 +has_seconds_running bool +msec_tologonthistime u32 +has_msec_tologonthistime bool +count_bad_cms u32 +has_count_bad_cms bool +} +pub fn (o &CMsgClientConnectionStatsStatsLogon) pack() []byte { +mut res := []byte{} +if o.has_connect_attempts { +res << vproto.pack_int32_field(o.connect_attempts, 1) +} + +if o.has_connect_successes { +res << vproto.pack_int32_field(o.connect_successes, 2) +} + +if o.has_connect_failures { +res << vproto.pack_int32_field(o.connect_failures, 3) +} + +if o.has_connections_dropped { +res << vproto.pack_int32_field(o.connections_dropped, 4) +} + +if o.has_seconds_running { +res << vproto.pack_uint32_field(o.seconds_running, 5) +} + +if o.has_msec_tologonthistime { +res << vproto.pack_uint32_field(o.msec_tologonthistime, 6) +} + +if o.has_count_bad_cms { +res << vproto.pack_uint32_field(o.count_bad_cms, 7) +} + +return res +} + +pub fn cmsgclientconnectionstatsstatslogon_unpack(buf []byte) ?CMsgClientConnectionStatsStatsLogon { +mut res := CMsgClientConnectionStatsStatsLogon{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_connect_attempts = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.connect_attempts = v +i = ii +} + +2 { +res.has_connect_successes = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.connect_successes = v +i = ii +} + +3 { +res.has_connect_failures = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.connect_failures = v +i = ii +} + +4 { +res.has_connections_dropped = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.connections_dropped = v +i = ii +} + +5 { +res.has_seconds_running = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_running = v +i = ii +} + +6 { +res.has_msec_tologonthistime = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.msec_tologonthistime = v +i = ii +} + +7 { +res.has_count_bad_cms = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.count_bad_cms = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientconnectionstatsstatslogon() CMsgClientConnectionStatsStatsLogon { +return CMsgClientConnectionStatsStatsLogon{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientconnectionstatsstatslogon(o CMsgClientConnectionStatsStatsLogon, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientconnectionstatsstatslogon(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientConnectionStatsStatsLogon) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientconnectionstatsstatslogon_unpack(v)? +return i, unpacked +} +pub struct CMsgClientConnectionStatsStatsUDp { +mut: +unknown_fields []vproto.UnknownField +pub mut: +pkts_sent u64 +has_pkts_sent bool +bytes_sent u64 +has_bytes_sent bool +pkts_recv u64 +has_pkts_recv bool +pkts_processed u64 +has_pkts_processed bool +bytes_recv u64 +has_bytes_recv bool +} +pub fn (o &CMsgClientConnectionStatsStatsUDp) pack() []byte { +mut res := []byte{} +if o.has_pkts_sent { +res << vproto.pack_uint64_field(o.pkts_sent, 1) +} + +if o.has_bytes_sent { +res << vproto.pack_uint64_field(o.bytes_sent, 2) +} + +if o.has_pkts_recv { +res << vproto.pack_uint64_field(o.pkts_recv, 3) +} + +if o.has_pkts_processed { +res << vproto.pack_uint64_field(o.pkts_processed, 4) +} + +if o.has_bytes_recv { +res << vproto.pack_uint64_field(o.bytes_recv, 5) +} + +return res +} + +pub fn cmsgclientconnectionstatsstatsudp_unpack(buf []byte) ?CMsgClientConnectionStatsStatsUDp { +mut res := CMsgClientConnectionStatsStatsUDp{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_pkts_sent = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.pkts_sent = v +i = ii +} + +2 { +res.has_bytes_sent = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.bytes_sent = v +i = ii +} + +3 { +res.has_pkts_recv = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.pkts_recv = v +i = ii +} + +4 { +res.has_pkts_processed = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.pkts_processed = v +i = ii +} + +5 { +res.has_bytes_recv = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.bytes_recv = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientconnectionstatsstatsudp() CMsgClientConnectionStatsStatsUDp { +return CMsgClientConnectionStatsStatsUDp{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientconnectionstatsstatsudp(o CMsgClientConnectionStatsStatsUDp, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientconnectionstatsstatsudp(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientConnectionStatsStatsUDp) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientconnectionstatsstatsudp_unpack(v)? +return i, unpacked +} +pub struct CMsgClientConnectionStatsStatsVConn { +mut: +unknown_fields []vproto.UnknownField +pub mut: +connections_udp u32 +has_connections_udp bool +connections_tcp u32 +has_connections_tcp bool +stats_udp CMsgClientConnectionStatsStatsUDp +has_stats_udp bool +pkts_abandoned u64 +has_pkts_abandoned bool +conn_req_received u64 +has_conn_req_received bool +pkts_resent u64 +has_pkts_resent bool +msgs_sent u64 +has_msgs_sent bool +msgs_sent_failed u64 +has_msgs_sent_failed bool +msgs_recv u64 +has_msgs_recv bool +datagrams_sent u64 +has_datagrams_sent bool +datagrams_recv u64 +has_datagrams_recv bool +bad_pkts_recv u64 +has_bad_pkts_recv bool +unknown_conn_pkts_recv u64 +has_unknown_conn_pkts_recv bool +missed_pkts_recv u64 +has_missed_pkts_recv bool +dup_pkts_recv u64 +has_dup_pkts_recv bool +failed_connect_challenges u64 +has_failed_connect_challenges bool +micro_sec_avg_latency u32 +has_micro_sec_avg_latency bool +micro_sec_min_latency u32 +has_micro_sec_min_latency bool +micro_sec_max_latency u32 +has_micro_sec_max_latency bool +mem_pool_msg_in_use u32 +has_mem_pool_msg_in_use bool +} +pub fn (o &CMsgClientConnectionStatsStatsVConn) pack() []byte { +mut res := []byte{} +if o.has_connections_udp { +res << vproto.pack_uint32_field(o.connections_udp, 1) +} + +if o.has_connections_tcp { +res << vproto.pack_uint32_field(o.connections_tcp, 2) +} + +if o.has_stats_udp { +res << zzz_vproto_internal_pack_cmsgclientconnectionstatsstatsudp(o.stats_udp, 3) +} + +if o.has_pkts_abandoned { +res << vproto.pack_uint64_field(o.pkts_abandoned, 4) +} + +if o.has_conn_req_received { +res << vproto.pack_uint64_field(o.conn_req_received, 5) +} + +if o.has_pkts_resent { +res << vproto.pack_uint64_field(o.pkts_resent, 6) +} + +if o.has_msgs_sent { +res << vproto.pack_uint64_field(o.msgs_sent, 7) +} + +if o.has_msgs_sent_failed { +res << vproto.pack_uint64_field(o.msgs_sent_failed, 8) +} + +if o.has_msgs_recv { +res << vproto.pack_uint64_field(o.msgs_recv, 9) +} + +if o.has_datagrams_sent { +res << vproto.pack_uint64_field(o.datagrams_sent, 10) +} + +if o.has_datagrams_recv { +res << vproto.pack_uint64_field(o.datagrams_recv, 11) +} + +if o.has_bad_pkts_recv { +res << vproto.pack_uint64_field(o.bad_pkts_recv, 12) +} + +if o.has_unknown_conn_pkts_recv { +res << vproto.pack_uint64_field(o.unknown_conn_pkts_recv, 13) +} + +if o.has_missed_pkts_recv { +res << vproto.pack_uint64_field(o.missed_pkts_recv, 14) +} + +if o.has_dup_pkts_recv { +res << vproto.pack_uint64_field(o.dup_pkts_recv, 15) +} + +if o.has_failed_connect_challenges { +res << vproto.pack_uint64_field(o.failed_connect_challenges, 16) +} + +if o.has_micro_sec_avg_latency { +res << vproto.pack_uint32_field(o.micro_sec_avg_latency, 17) +} + +if o.has_micro_sec_min_latency { +res << vproto.pack_uint32_field(o.micro_sec_min_latency, 18) +} + +if o.has_micro_sec_max_latency { +res << vproto.pack_uint32_field(o.micro_sec_max_latency, 19) +} + +if o.has_mem_pool_msg_in_use { +res << vproto.pack_uint32_field(o.mem_pool_msg_in_use, 20) +} + +return res +} + +pub fn cmsgclientconnectionstatsstatsvconn_unpack(buf []byte) ?CMsgClientConnectionStatsStatsVConn { +mut res := CMsgClientConnectionStatsStatsVConn{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_connections_udp = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.connections_udp = v +i = ii +} + +2 { +res.has_connections_tcp = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.connections_tcp = v +i = ii +} + +3 { +res.has_stats_udp = true +ii, v := zzz_vproto_internal_unpack_cmsgclientconnectionstatsstatsudp(cur_buf, tag_wiretype.wire_type)? +res.stats_udp = v +i = ii +} + +4 { +res.has_pkts_abandoned = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.pkts_abandoned = v +i = ii +} + +5 { +res.has_conn_req_received = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.conn_req_received = v +i = ii +} + +6 { +res.has_pkts_resent = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.pkts_resent = v +i = ii +} + +7 { +res.has_msgs_sent = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.msgs_sent = v +i = ii +} + +8 { +res.has_msgs_sent_failed = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.msgs_sent_failed = v +i = ii +} + +9 { +res.has_msgs_recv = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.msgs_recv = v +i = ii +} + +10 { +res.has_datagrams_sent = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.datagrams_sent = v +i = ii +} + +11 { +res.has_datagrams_recv = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.datagrams_recv = v +i = ii +} + +12 { +res.has_bad_pkts_recv = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.bad_pkts_recv = v +i = ii +} + +13 { +res.has_unknown_conn_pkts_recv = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.unknown_conn_pkts_recv = v +i = ii +} + +14 { +res.has_missed_pkts_recv = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.missed_pkts_recv = v +i = ii +} + +15 { +res.has_dup_pkts_recv = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.dup_pkts_recv = v +i = ii +} + +16 { +res.has_failed_connect_challenges = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.failed_connect_challenges = v +i = ii +} + +17 { +res.has_micro_sec_avg_latency = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.micro_sec_avg_latency = v +i = ii +} + +18 { +res.has_micro_sec_min_latency = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.micro_sec_min_latency = v +i = ii +} + +19 { +res.has_micro_sec_max_latency = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.micro_sec_max_latency = v +i = ii +} + +20 { +res.has_mem_pool_msg_in_use = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.mem_pool_msg_in_use = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientconnectionstatsstatsvconn() CMsgClientConnectionStatsStatsVConn { +return CMsgClientConnectionStatsStatsVConn{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientconnectionstatsstatsvconn(o CMsgClientConnectionStatsStatsVConn, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientconnectionstatsstatsvconn(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientConnectionStatsStatsVConn) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientconnectionstatsstatsvconn_unpack(v)? +return i, unpacked +} +pub struct CMsgClientConnectionStats { +mut: +unknown_fields []vproto.UnknownField +pub mut: +stats_logon CMsgClientConnectionStatsStatsLogon +has_stats_logon bool +stats_vconn CMsgClientConnectionStatsStatsVConn +has_stats_vconn bool +} +pub fn (o &CMsgClientConnectionStats) pack() []byte { +mut res := []byte{} +if o.has_stats_logon { +res << zzz_vproto_internal_pack_cmsgclientconnectionstatsstatslogon(o.stats_logon, 1) +} + +if o.has_stats_vconn { +res << zzz_vproto_internal_pack_cmsgclientconnectionstatsstatsvconn(o.stats_vconn, 2) +} + +return res +} + +pub fn cmsgclientconnectionstats_unpack(buf []byte) ?CMsgClientConnectionStats { +mut res := CMsgClientConnectionStats{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_stats_logon = true +ii, v := zzz_vproto_internal_unpack_cmsgclientconnectionstatsstatslogon(cur_buf, tag_wiretype.wire_type)? +res.stats_logon = v +i = ii +} + +2 { +res.has_stats_vconn = true +ii, v := zzz_vproto_internal_unpack_cmsgclientconnectionstatsstatsvconn(cur_buf, tag_wiretype.wire_type)? +res.stats_vconn = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientconnectionstats() CMsgClientConnectionStats { +return CMsgClientConnectionStats{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientconnectionstats(o CMsgClientConnectionStats, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientconnectionstats(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientConnectionStats) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientconnectionstats_unpack(v)? +return i, unpacked +} +pub struct CMsgClientServersAvailableServerTypesAvailable { +mut: +unknown_fields []vproto.UnknownField +pub mut: +server u32 +has_server bool +changed bool +has_changed bool +} +pub fn (o &CMsgClientServersAvailableServerTypesAvailable) pack() []byte { +mut res := []byte{} +if o.has_server { +res << vproto.pack_uint32_field(o.server, 1) +} + +if o.has_changed { +res << vproto.pack_bool_field(o.changed, 2) +} + +return res +} + +pub fn cmsgclientserversavailableservertypesavailable_unpack(buf []byte) ?CMsgClientServersAvailableServerTypesAvailable { +mut res := CMsgClientServersAvailableServerTypesAvailable{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_server = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.server = v +i = ii +} + +2 { +res.has_changed = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.changed = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientserversavailableservertypesavailable() CMsgClientServersAvailableServerTypesAvailable { +return CMsgClientServersAvailableServerTypesAvailable{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientserversavailableservertypesavailable(o CMsgClientServersAvailableServerTypesAvailable, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientserversavailableservertypesavailable(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientServersAvailableServerTypesAvailable) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientserversavailableservertypesavailable_unpack(v)? +return i, unpacked +} +pub struct CMsgClientServersAvailable { +mut: +unknown_fields []vproto.UnknownField +pub mut: +server_types_available []CMsgClientServersAvailableServerTypesAvailable +server_type_for_auth_services u32 +has_server_type_for_auth_services bool +} +pub fn (o &CMsgClientServersAvailable) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.server_types_available { +res << zzz_vproto_internal_pack_cmsgclientserversavailableservertypesavailable(x, 1) +} + +if o.has_server_type_for_auth_services { +res << vproto.pack_uint32_field(o.server_type_for_auth_services, 2) +} + +return res +} + +pub fn cmsgclientserversavailable_unpack(buf []byte) ?CMsgClientServersAvailable { +mut res := CMsgClientServersAvailable{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientserversavailableservertypesavailable(cur_buf, tag_wiretype.wire_type)? +res.server_types_available << v +i = ii +} + +2 { +res.has_server_type_for_auth_services = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.server_type_for_auth_services = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientserversavailable() CMsgClientServersAvailable { +return CMsgClientServersAvailable{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientserversavailable(o CMsgClientServersAvailable, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientserversavailable(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientServersAvailable) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientserversavailable_unpack(v)? +return i, unpacked +} +pub struct CMsgClientGetUserStats { +mut: +unknown_fields []vproto.UnknownField +pub mut: +game_id u64 +has_game_id bool +crc_stats u32 +has_crc_stats bool +schema_local_version int +has_schema_local_version bool +steam_id_for_user u64 +has_steam_id_for_user bool +} +pub fn (o &CMsgClientGetUserStats) pack() []byte { +mut res := []byte{} +if o.has_game_id { +res << vproto.pack_64bit_field(o.game_id, 1) +} + +if o.has_crc_stats { +res << vproto.pack_uint32_field(o.crc_stats, 2) +} + +if o.has_schema_local_version { +res << vproto.pack_int32_field(o.schema_local_version, 3) +} + +if o.has_steam_id_for_user { +res << vproto.pack_64bit_field(o.steam_id_for_user, 4) +} + +return res +} + +pub fn cmsgclientgetuserstats_unpack(buf []byte) ?CMsgClientGetUserStats { +mut res := CMsgClientGetUserStats{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_game_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.game_id = v +i = ii +} + +2 { +res.has_crc_stats = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.crc_stats = v +i = ii +} + +3 { +res.has_schema_local_version = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.schema_local_version = v +i = ii +} + +4 { +res.has_steam_id_for_user = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id_for_user = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientgetuserstats() CMsgClientGetUserStats { +return CMsgClientGetUserStats{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientgetuserstats(o CMsgClientGetUserStats, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientgetuserstats(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientGetUserStats) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientgetuserstats_unpack(v)? +return i, unpacked +} +pub struct CMsgClientGetUserStatsResponseStats { +mut: +unknown_fields []vproto.UnknownField +pub mut: +stat_id u32 +has_stat_id bool +stat_value u32 +has_stat_value bool +} +pub fn (o &CMsgClientGetUserStatsResponseStats) pack() []byte { +mut res := []byte{} +if o.has_stat_id { +res << vproto.pack_uint32_field(o.stat_id, 1) +} + +if o.has_stat_value { +res << vproto.pack_uint32_field(o.stat_value, 2) +} + +return res +} + +pub fn cmsgclientgetuserstatsresponsestats_unpack(buf []byte) ?CMsgClientGetUserStatsResponseStats { +mut res := CMsgClientGetUserStatsResponseStats{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_stat_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.stat_id = v +i = ii +} + +2 { +res.has_stat_value = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.stat_value = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientgetuserstatsresponsestats() CMsgClientGetUserStatsResponseStats { +return CMsgClientGetUserStatsResponseStats{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientgetuserstatsresponsestats(o CMsgClientGetUserStatsResponseStats, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientgetuserstatsresponsestats(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientGetUserStatsResponseStats) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientgetuserstatsresponsestats_unpack(v)? +return i, unpacked +} +pub struct CMsgClientGetUserStatsResponseAchievementBlocks { +mut: +unknown_fields []vproto.UnknownField +pub mut: +achievement_id u32 +has_achievement_id bool +unlock_time []u32 +} +pub fn (o &CMsgClientGetUserStatsResponseAchievementBlocks) pack() []byte { +mut res := []byte{} +if o.has_achievement_id { +res << vproto.pack_uint32_field(o.achievement_id, 1) +} + +// [packed=false] +for _, x in o.unlock_time { +res << vproto.pack_32bit_field(x, 2) +} + +return res +} + +pub fn cmsgclientgetuserstatsresponseachievementblocks_unpack(buf []byte) ?CMsgClientGetUserStatsResponseAchievementBlocks { +mut res := CMsgClientGetUserStatsResponseAchievementBlocks{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_achievement_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.achievement_id = v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.unlock_time << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientgetuserstatsresponseachievementblocks() CMsgClientGetUserStatsResponseAchievementBlocks { +return CMsgClientGetUserStatsResponseAchievementBlocks{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientgetuserstatsresponseachievementblocks(o CMsgClientGetUserStatsResponseAchievementBlocks, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientgetuserstatsresponseachievementblocks(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientGetUserStatsResponseAchievementBlocks) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientgetuserstatsresponseachievementblocks_unpack(v)? +return i, unpacked +} +pub struct CMsgClientGetUserStatsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +game_id u64 +has_game_id bool +eresult int +has_eresult bool +crc_stats u32 +has_crc_stats bool +schema []byte +has_schema bool +stats []CMsgClientGetUserStatsResponseStats +achievement_blocks []CMsgClientGetUserStatsResponseAchievementBlocks +} +pub fn (o &CMsgClientGetUserStatsResponse) pack() []byte { +mut res := []byte{} +if o.has_game_id { +res << vproto.pack_64bit_field(o.game_id, 1) +} + +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 2) +} + +if o.has_crc_stats { +res << vproto.pack_uint32_field(o.crc_stats, 3) +} + +if o.has_schema { +res << vproto.pack_bytes_field(o.schema, 4) +} + +// [packed=false] +for _, x in o.stats { +res << zzz_vproto_internal_pack_cmsgclientgetuserstatsresponsestats(x, 5) +} + +// [packed=false] +for _, x in o.achievement_blocks { +res << zzz_vproto_internal_pack_cmsgclientgetuserstatsresponseachievementblocks(x, 6) +} + +return res +} + +pub fn cmsgclientgetuserstatsresponse_unpack(buf []byte) ?CMsgClientGetUserStatsResponse { +mut res := CMsgClientGetUserStatsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_game_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.game_id = v +i = ii +} + +2 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +3 { +res.has_crc_stats = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.crc_stats = v +i = ii +} + +4 { +res.has_schema = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.schema = v +i = ii +} + +5 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientgetuserstatsresponsestats(cur_buf, tag_wiretype.wire_type)? +res.stats << v +i = ii +} + +6 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientgetuserstatsresponseachievementblocks(cur_buf, tag_wiretype.wire_type)? +res.achievement_blocks << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientgetuserstatsresponse() CMsgClientGetUserStatsResponse { +return CMsgClientGetUserStatsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientgetuserstatsresponse(o CMsgClientGetUserStatsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientgetuserstatsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientGetUserStatsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientgetuserstatsresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientStoreUserStatsResponseStatsFailedValidation { +mut: +unknown_fields []vproto.UnknownField +pub mut: +stat_id u32 +has_stat_id bool +reverted_stat_value u32 +has_reverted_stat_value bool +} +pub fn (o &CMsgClientStoreUserStatsResponseStatsFailedValidation) pack() []byte { +mut res := []byte{} +if o.has_stat_id { +res << vproto.pack_uint32_field(o.stat_id, 1) +} + +if o.has_reverted_stat_value { +res << vproto.pack_uint32_field(o.reverted_stat_value, 2) +} + +return res +} + +pub fn cmsgclientstoreuserstatsresponsestatsfailedvalidation_unpack(buf []byte) ?CMsgClientStoreUserStatsResponseStatsFailedValidation { +mut res := CMsgClientStoreUserStatsResponseStatsFailedValidation{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_stat_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.stat_id = v +i = ii +} + +2 { +res.has_reverted_stat_value = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.reverted_stat_value = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientstoreuserstatsresponsestatsfailedvalidation() CMsgClientStoreUserStatsResponseStatsFailedValidation { +return CMsgClientStoreUserStatsResponseStatsFailedValidation{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientstoreuserstatsresponsestatsfailedvalidation(o CMsgClientStoreUserStatsResponseStatsFailedValidation, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientstoreuserstatsresponsestatsfailedvalidation(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientStoreUserStatsResponseStatsFailedValidation) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientstoreuserstatsresponsestatsfailedvalidation_unpack(v)? +return i, unpacked +} +pub struct CMsgClientStoreUserStatsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +game_id u64 +has_game_id bool +eresult int +has_eresult bool +crc_stats u32 +has_crc_stats bool +stats_failed_validation []CMsgClientStoreUserStatsResponseStatsFailedValidation +stats_out_of_date bool +has_stats_out_of_date bool +} +pub fn (o &CMsgClientStoreUserStatsResponse) pack() []byte { +mut res := []byte{} +if o.has_game_id { +res << vproto.pack_64bit_field(o.game_id, 1) +} + +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 2) +} + +if o.has_crc_stats { +res << vproto.pack_uint32_field(o.crc_stats, 3) +} + +// [packed=false] +for _, x in o.stats_failed_validation { +res << zzz_vproto_internal_pack_cmsgclientstoreuserstatsresponsestatsfailedvalidation(x, 4) +} + +if o.has_stats_out_of_date { +res << vproto.pack_bool_field(o.stats_out_of_date, 5) +} + +return res +} + +pub fn cmsgclientstoreuserstatsresponse_unpack(buf []byte) ?CMsgClientStoreUserStatsResponse { +mut res := CMsgClientStoreUserStatsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_game_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.game_id = v +i = ii +} + +2 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +3 { +res.has_crc_stats = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.crc_stats = v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientstoreuserstatsresponsestatsfailedvalidation(cur_buf, tag_wiretype.wire_type)? +res.stats_failed_validation << v +i = ii +} + +5 { +res.has_stats_out_of_date = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.stats_out_of_date = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientstoreuserstatsresponse() CMsgClientStoreUserStatsResponse { +return CMsgClientStoreUserStatsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientstoreuserstatsresponse(o CMsgClientStoreUserStatsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientstoreuserstatsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientStoreUserStatsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientstoreuserstatsresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientStoreUserStats2Stats { +mut: +unknown_fields []vproto.UnknownField +pub mut: +stat_id u32 +has_stat_id bool +stat_value u32 +has_stat_value bool +} +pub fn (o &CMsgClientStoreUserStats2Stats) pack() []byte { +mut res := []byte{} +if o.has_stat_id { +res << vproto.pack_uint32_field(o.stat_id, 1) +} + +if o.has_stat_value { +res << vproto.pack_uint32_field(o.stat_value, 2) +} + +return res +} + +pub fn cmsgclientstoreuserstats2stats_unpack(buf []byte) ?CMsgClientStoreUserStats2Stats { +mut res := CMsgClientStoreUserStats2Stats{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_stat_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.stat_id = v +i = ii +} + +2 { +res.has_stat_value = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.stat_value = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientstoreuserstats2stats() CMsgClientStoreUserStats2Stats { +return CMsgClientStoreUserStats2Stats{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientstoreuserstats2stats(o CMsgClientStoreUserStats2Stats, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientstoreuserstats2stats(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientStoreUserStats2Stats) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientstoreuserstats2stats_unpack(v)? +return i, unpacked +} +pub struct CMsgClientStoreUserStats2 { +mut: +unknown_fields []vproto.UnknownField +pub mut: +game_id u64 +has_game_id bool +settor_steam_id u64 +has_settor_steam_id bool +settee_steam_id u64 +has_settee_steam_id bool +crc_stats u32 +has_crc_stats bool +explicit_reset bool +has_explicit_reset bool +stats []CMsgClientStoreUserStats2Stats +} +pub fn (o &CMsgClientStoreUserStats2) pack() []byte { +mut res := []byte{} +if o.has_game_id { +res << vproto.pack_64bit_field(o.game_id, 1) +} + +if o.has_settor_steam_id { +res << vproto.pack_64bit_field(o.settor_steam_id, 2) +} + +if o.has_settee_steam_id { +res << vproto.pack_64bit_field(o.settee_steam_id, 3) +} + +if o.has_crc_stats { +res << vproto.pack_uint32_field(o.crc_stats, 4) +} + +if o.has_explicit_reset { +res << vproto.pack_bool_field(o.explicit_reset, 5) +} + +// [packed=false] +for _, x in o.stats { +res << zzz_vproto_internal_pack_cmsgclientstoreuserstats2stats(x, 6) +} + +return res +} + +pub fn cmsgclientstoreuserstats2_unpack(buf []byte) ?CMsgClientStoreUserStats2 { +mut res := CMsgClientStoreUserStats2{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_game_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.game_id = v +i = ii +} + +2 { +res.has_settor_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.settor_steam_id = v +i = ii +} + +3 { +res.has_settee_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.settee_steam_id = v +i = ii +} + +4 { +res.has_crc_stats = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.crc_stats = v +i = ii +} + +5 { +res.has_explicit_reset = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.explicit_reset = v +i = ii +} + +6 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientstoreuserstats2stats(cur_buf, tag_wiretype.wire_type)? +res.stats << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientstoreuserstats2() CMsgClientStoreUserStats2 { +return CMsgClientStoreUserStats2{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientstoreuserstats2(o CMsgClientStoreUserStats2, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientstoreuserstats2(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientStoreUserStats2) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientstoreuserstats2_unpack(v)? +return i, unpacked +} +pub struct CMsgClientStatsUpdatedUpdatedStats { +mut: +unknown_fields []vproto.UnknownField +pub mut: +stat_id u32 +has_stat_id bool +stat_value u32 +has_stat_value bool +} +pub fn (o &CMsgClientStatsUpdatedUpdatedStats) pack() []byte { +mut res := []byte{} +if o.has_stat_id { +res << vproto.pack_uint32_field(o.stat_id, 1) +} + +if o.has_stat_value { +res << vproto.pack_uint32_field(o.stat_value, 2) +} + +return res +} + +pub fn cmsgclientstatsupdatedupdatedstats_unpack(buf []byte) ?CMsgClientStatsUpdatedUpdatedStats { +mut res := CMsgClientStatsUpdatedUpdatedStats{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_stat_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.stat_id = v +i = ii +} + +2 { +res.has_stat_value = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.stat_value = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientstatsupdatedupdatedstats() CMsgClientStatsUpdatedUpdatedStats { +return CMsgClientStatsUpdatedUpdatedStats{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientstatsupdatedupdatedstats(o CMsgClientStatsUpdatedUpdatedStats, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientstatsupdatedupdatedstats(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientStatsUpdatedUpdatedStats) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientstatsupdatedupdatedstats_unpack(v)? +return i, unpacked +} +pub struct CMsgClientStatsUpdated { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id u64 +has_steam_id bool +game_id u64 +has_game_id bool +crc_stats u32 +has_crc_stats bool +updated_stats []CMsgClientStatsUpdatedUpdatedStats +} +pub fn (o &CMsgClientStatsUpdated) pack() []byte { +mut res := []byte{} +if o.has_steam_id { +res << vproto.pack_64bit_field(o.steam_id, 1) +} + +if o.has_game_id { +res << vproto.pack_64bit_field(o.game_id, 2) +} + +if o.has_crc_stats { +res << vproto.pack_uint32_field(o.crc_stats, 3) +} + +// [packed=false] +for _, x in o.updated_stats { +res << zzz_vproto_internal_pack_cmsgclientstatsupdatedupdatedstats(x, 4) +} + +return res +} + +pub fn cmsgclientstatsupdated_unpack(buf []byte) ?CMsgClientStatsUpdated { +mut res := CMsgClientStatsUpdated{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id = v +i = ii +} + +2 { +res.has_game_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.game_id = v +i = ii +} + +3 { +res.has_crc_stats = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.crc_stats = v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientstatsupdatedupdatedstats(cur_buf, tag_wiretype.wire_type)? +res.updated_stats << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientstatsupdated() CMsgClientStatsUpdated { +return CMsgClientStatsUpdated{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientstatsupdated(o CMsgClientStatsUpdated, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientstatsupdated(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientStatsUpdated) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientstatsupdated_unpack(v)? +return i, unpacked +} +pub struct CMsgClientStoreUserStatsStatsToStore { +mut: +unknown_fields []vproto.UnknownField +pub mut: +stat_id u32 +has_stat_id bool +stat_value u32 +has_stat_value bool +} +pub fn (o &CMsgClientStoreUserStatsStatsToStore) pack() []byte { +mut res := []byte{} +if o.has_stat_id { +res << vproto.pack_uint32_field(o.stat_id, 1) +} + +if o.has_stat_value { +res << vproto.pack_uint32_field(o.stat_value, 2) +} + +return res +} + +pub fn cmsgclientstoreuserstatsstatstostore_unpack(buf []byte) ?CMsgClientStoreUserStatsStatsToStore { +mut res := CMsgClientStoreUserStatsStatsToStore{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_stat_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.stat_id = v +i = ii +} + +2 { +res.has_stat_value = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.stat_value = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientstoreuserstatsstatstostore() CMsgClientStoreUserStatsStatsToStore { +return CMsgClientStoreUserStatsStatsToStore{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientstoreuserstatsstatstostore(o CMsgClientStoreUserStatsStatsToStore, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientstoreuserstatsstatstostore(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientStoreUserStatsStatsToStore) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientstoreuserstatsstatstostore_unpack(v)? +return i, unpacked +} +pub struct CMsgClientStoreUserStats { +mut: +unknown_fields []vproto.UnknownField +pub mut: +game_id u64 +has_game_id bool +explicit_reset bool +has_explicit_reset bool +stats_to_store []CMsgClientStoreUserStatsStatsToStore +} +pub fn (o &CMsgClientStoreUserStats) pack() []byte { +mut res := []byte{} +if o.has_game_id { +res << vproto.pack_64bit_field(o.game_id, 1) +} + +if o.has_explicit_reset { +res << vproto.pack_bool_field(o.explicit_reset, 2) +} + +// [packed=false] +for _, x in o.stats_to_store { +res << zzz_vproto_internal_pack_cmsgclientstoreuserstatsstatstostore(x, 3) +} + +return res +} + +pub fn cmsgclientstoreuserstats_unpack(buf []byte) ?CMsgClientStoreUserStats { +mut res := CMsgClientStoreUserStats{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_game_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.game_id = v +i = ii +} + +2 { +res.has_explicit_reset = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.explicit_reset = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientstoreuserstatsstatstostore(cur_buf, tag_wiretype.wire_type)? +res.stats_to_store << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientstoreuserstats() CMsgClientStoreUserStats { +return CMsgClientStoreUserStats{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientstoreuserstats(o CMsgClientStoreUserStats, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientstoreuserstats(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientStoreUserStats) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientstoreuserstats_unpack(v)? +return i, unpacked +} +pub struct CMsgClientGetClientDetails { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CMsgClientGetClientDetails) pack() []byte { +res := []byte{} +return res +} + +pub fn cmsgclientgetclientdetails_unpack(buf []byte) ?CMsgClientGetClientDetails { +res := CMsgClientGetClientDetails{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientgetclientdetails() CMsgClientGetClientDetails { +return CMsgClientGetClientDetails{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientgetclientdetails(o CMsgClientGetClientDetails, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientgetclientdetails(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientGetClientDetails) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientgetclientdetails_unpack(v)? +return i, unpacked +} +pub struct CMsgClientReportOverlayDetourFailure { +mut: +unknown_fields []vproto.UnknownField +pub mut: +failure_strings []string +} +pub fn (o &CMsgClientReportOverlayDetourFailure) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.failure_strings { +res << vproto.pack_string_field(x, 1) +} + +return res +} + +pub fn cmsgclientreportoverlaydetourfailure_unpack(buf []byte) ?CMsgClientReportOverlayDetourFailure { +mut res := CMsgClientReportOverlayDetourFailure{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.failure_strings << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientreportoverlaydetourfailure() CMsgClientReportOverlayDetourFailure { +return CMsgClientReportOverlayDetourFailure{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientreportoverlaydetourfailure(o CMsgClientReportOverlayDetourFailure, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientreportoverlaydetourfailure(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientReportOverlayDetourFailure) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientreportoverlaydetourfailure_unpack(v)? +return i, unpacked +} +pub struct CMsgClientGetClientDetailsResponseGame { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +extra_info string +has_extra_info bool +time_running_sec u32 +has_time_running_sec bool +} +pub fn (o &CMsgClientGetClientDetailsResponseGame) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_extra_info { +res << vproto.pack_string_field(o.extra_info, 2) +} + +if o.has_time_running_sec { +res << vproto.pack_uint32_field(o.time_running_sec, 3) +} + +return res +} + +pub fn cmsgclientgetclientdetailsresponsegame_unpack(buf []byte) ?CMsgClientGetClientDetailsResponseGame { +mut res := CMsgClientGetClientDetailsResponseGame{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_extra_info = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.extra_info = v +i = ii +} + +3 { +res.has_time_running_sec = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_running_sec = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientgetclientdetailsresponsegame() CMsgClientGetClientDetailsResponseGame { +return CMsgClientGetClientDetailsResponseGame{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientgetclientdetailsresponsegame(o CMsgClientGetClientDetailsResponseGame, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientgetclientdetailsresponsegame(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientGetClientDetailsResponseGame) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientgetclientdetailsresponsegame_unpack(v)? +return i, unpacked +} +pub struct CMsgClientGetClientDetailsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +package_version u32 +has_package_version bool +protocol_version u32 +has_protocol_version bool +os string +has_os bool +machine_name string +has_machine_name bool +ip_public string +has_ip_public bool +ip_private string +has_ip_private bool +bytes_available u64 +has_bytes_available bool +games_running []CMsgClientGetClientDetailsResponseGame +} +pub fn (o &CMsgClientGetClientDetailsResponse) pack() []byte { +mut res := []byte{} +if o.has_package_version { +res << vproto.pack_uint32_field(o.package_version, 1) +} + +if o.has_protocol_version { +res << vproto.pack_uint32_field(o.protocol_version, 8) +} + +if o.has_os { +res << vproto.pack_string_field(o.os, 2) +} + +if o.has_machine_name { +res << vproto.pack_string_field(o.machine_name, 3) +} + +if o.has_ip_public { +res << vproto.pack_string_field(o.ip_public, 4) +} + +if o.has_ip_private { +res << vproto.pack_string_field(o.ip_private, 5) +} + +if o.has_bytes_available { +res << vproto.pack_uint64_field(o.bytes_available, 7) +} + +// [packed=false] +for _, x in o.games_running { +res << zzz_vproto_internal_pack_cmsgclientgetclientdetailsresponsegame(x, 6) +} + +return res +} + +pub fn cmsgclientgetclientdetailsresponse_unpack(buf []byte) ?CMsgClientGetClientDetailsResponse { +mut res := CMsgClientGetClientDetailsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_package_version = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.package_version = v +i = ii +} + +8 { +res.has_protocol_version = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.protocol_version = v +i = ii +} + +2 { +res.has_os = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.os = v +i = ii +} + +3 { +res.has_machine_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.machine_name = v +i = ii +} + +4 { +res.has_ip_public = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.ip_public = v +i = ii +} + +5 { +res.has_ip_private = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.ip_private = v +i = ii +} + +7 { +res.has_bytes_available = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.bytes_available = v +i = ii +} + +6 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientgetclientdetailsresponsegame(cur_buf, tag_wiretype.wire_type)? +res.games_running << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientgetclientdetailsresponse() CMsgClientGetClientDetailsResponse { +return CMsgClientGetClientDetailsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientgetclientdetailsresponse(o CMsgClientGetClientDetailsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientgetclientdetailsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientGetClientDetailsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientgetclientdetailsresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientGetClientAppList { +mut: +unknown_fields []vproto.UnknownField +pub mut: +media bool +has_media bool +tools bool +has_tools bool +games bool +has_games bool +only_installed bool +has_only_installed bool +only_changing bool +has_only_changing bool +comics bool +has_comics bool +} +pub fn (o &CMsgClientGetClientAppList) pack() []byte { +mut res := []byte{} +if o.has_media { +res << vproto.pack_bool_field(o.media, 1) +} + +if o.has_tools { +res << vproto.pack_bool_field(o.tools, 2) +} + +if o.has_games { +res << vproto.pack_bool_field(o.games, 3) +} + +if o.has_only_installed { +res << vproto.pack_bool_field(o.only_installed, 4) +} + +if o.has_only_changing { +res << vproto.pack_bool_field(o.only_changing, 5) +} + +if o.has_comics { +res << vproto.pack_bool_field(o.comics, 6) +} + +return res +} + +pub fn cmsgclientgetclientapplist_unpack(buf []byte) ?CMsgClientGetClientAppList { +mut res := CMsgClientGetClientAppList{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_media = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.media = v +i = ii +} + +2 { +res.has_tools = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.tools = v +i = ii +} + +3 { +res.has_games = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.games = v +i = ii +} + +4 { +res.has_only_installed = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.only_installed = v +i = ii +} + +5 { +res.has_only_changing = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.only_changing = v +i = ii +} + +6 { +res.has_comics = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.comics = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientgetclientapplist() CMsgClientGetClientAppList { +return CMsgClientGetClientAppList{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientgetclientapplist(o CMsgClientGetClientAppList, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientgetclientapplist(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientGetClientAppList) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientgetclientapplist_unpack(v)? +return i, unpacked +} +pub struct CMsgClientGetClientAppListResponseAppDLc { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +installed bool +has_installed bool +} +pub fn (o &CMsgClientGetClientAppListResponseAppDLc) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_installed { +res << vproto.pack_bool_field(o.installed, 2) +} + +return res +} + +pub fn cmsgclientgetclientapplistresponseappdlc_unpack(buf []byte) ?CMsgClientGetClientAppListResponseAppDLc { +mut res := CMsgClientGetClientAppListResponseAppDLc{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_installed = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.installed = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientgetclientapplistresponseappdlc() CMsgClientGetClientAppListResponseAppDLc { +return CMsgClientGetClientAppListResponseAppDLc{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientgetclientapplistresponseappdlc(o CMsgClientGetClientAppListResponseAppDLc, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientgetclientapplistresponseappdlc(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientGetClientAppListResponseAppDLc) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientgetclientapplistresponseappdlc_unpack(v)? +return i, unpacked +} +pub struct CMsgClientGetClientAppListResponseApp { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +category string +has_category bool +app_type string +has_app_type bool +favorite bool +has_favorite bool +installed bool +has_installed bool +auto_update bool +has_auto_update bool +bytes_downloaded u64 +has_bytes_downloaded bool +bytes_needed u64 +has_bytes_needed bool +bytes_download_rate u32 +has_bytes_download_rate bool +download_paused bool +has_download_paused bool +num_downloading u32 +has_num_downloading bool +num_paused u32 +has_num_paused bool +changing bool +has_changing bool +available_on_platform bool +has_available_on_platform bool +dlcs []CMsgClientGetClientAppListResponseAppDLc +} +pub fn (o &CMsgClientGetClientAppListResponseApp) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_category { +res << vproto.pack_string_field(o.category, 2) +} + +if o.has_app_type { +res << vproto.pack_string_field(o.app_type, 10) +} + +if o.has_favorite { +res << vproto.pack_bool_field(o.favorite, 3) +} + +if o.has_installed { +res << vproto.pack_bool_field(o.installed, 4) +} + +if o.has_auto_update { +res << vproto.pack_bool_field(o.auto_update, 5) +} + +if o.has_bytes_downloaded { +res << vproto.pack_uint64_field(o.bytes_downloaded, 6) +} + +if o.has_bytes_needed { +res << vproto.pack_uint64_field(o.bytes_needed, 7) +} + +if o.has_bytes_download_rate { +res << vproto.pack_uint32_field(o.bytes_download_rate, 8) +} + +if o.has_download_paused { +res << vproto.pack_bool_field(o.download_paused, 11) +} + +if o.has_num_downloading { +res << vproto.pack_uint32_field(o.num_downloading, 12) +} + +if o.has_num_paused { +res << vproto.pack_uint32_field(o.num_paused, 13) +} + +if o.has_changing { +res << vproto.pack_bool_field(o.changing, 14) +} + +if o.has_available_on_platform { +res << vproto.pack_bool_field(o.available_on_platform, 15) +} + +// [packed=false] +for _, x in o.dlcs { +res << zzz_vproto_internal_pack_cmsgclientgetclientapplistresponseappdlc(x, 9) +} + +return res +} + +pub fn cmsgclientgetclientapplistresponseapp_unpack(buf []byte) ?CMsgClientGetClientAppListResponseApp { +mut res := CMsgClientGetClientAppListResponseApp{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_category = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.category = v +i = ii +} + +10 { +res.has_app_type = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.app_type = v +i = ii +} + +3 { +res.has_favorite = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.favorite = v +i = ii +} + +4 { +res.has_installed = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.installed = v +i = ii +} + +5 { +res.has_auto_update = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.auto_update = v +i = ii +} + +6 { +res.has_bytes_downloaded = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.bytes_downloaded = v +i = ii +} + +7 { +res.has_bytes_needed = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.bytes_needed = v +i = ii +} + +8 { +res.has_bytes_download_rate = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.bytes_download_rate = v +i = ii +} + +11 { +res.has_download_paused = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.download_paused = v +i = ii +} + +12 { +res.has_num_downloading = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.num_downloading = v +i = ii +} + +13 { +res.has_num_paused = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.num_paused = v +i = ii +} + +14 { +res.has_changing = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.changing = v +i = ii +} + +15 { +res.has_available_on_platform = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.available_on_platform = v +i = ii +} + +9 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientgetclientapplistresponseappdlc(cur_buf, tag_wiretype.wire_type)? +res.dlcs << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientgetclientapplistresponseapp() CMsgClientGetClientAppListResponseApp { +return CMsgClientGetClientAppListResponseApp{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientgetclientapplistresponseapp(o CMsgClientGetClientAppListResponseApp, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientgetclientapplistresponseapp(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientGetClientAppListResponseApp) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientgetclientapplistresponseapp_unpack(v)? +return i, unpacked +} +pub struct CMsgClientGetClientAppListResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +apps []CMsgClientGetClientAppListResponseApp +bytes_available u64 +has_bytes_available bool +} +pub fn (o &CMsgClientGetClientAppListResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.apps { +res << zzz_vproto_internal_pack_cmsgclientgetclientapplistresponseapp(x, 1) +} + +if o.has_bytes_available { +res << vproto.pack_uint64_field(o.bytes_available, 2) +} + +return res +} + +pub fn cmsgclientgetclientapplistresponse_unpack(buf []byte) ?CMsgClientGetClientAppListResponse { +mut res := CMsgClientGetClientAppListResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientgetclientapplistresponseapp(cur_buf, tag_wiretype.wire_type)? +res.apps << v +i = ii +} + +2 { +res.has_bytes_available = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.bytes_available = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientgetclientapplistresponse() CMsgClientGetClientAppListResponse { +return CMsgClientGetClientAppListResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientgetclientapplistresponse(o CMsgClientGetClientAppListResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientgetclientapplistresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientGetClientAppListResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientgetclientapplistresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientInstallClientApp { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +} +pub fn (o &CMsgClientInstallClientApp) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +return res +} + +pub fn cmsgclientinstallclientapp_unpack(buf []byte) ?CMsgClientInstallClientApp { +mut res := CMsgClientInstallClientApp{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientinstallclientapp() CMsgClientInstallClientApp { +return CMsgClientInstallClientApp{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientinstallclientapp(o CMsgClientInstallClientApp, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientinstallclientapp(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientInstallClientApp) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientinstallclientapp_unpack(v)? +return i, unpacked +} +pub struct CMsgClientInstallClientAppResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +result u32 +has_result bool +} +pub fn (o &CMsgClientInstallClientAppResponse) pack() []byte { +mut res := []byte{} +if o.has_result { +res << vproto.pack_uint32_field(o.result, 1) +} + +return res +} + +pub fn cmsgclientinstallclientappresponse_unpack(buf []byte) ?CMsgClientInstallClientAppResponse { +mut res := CMsgClientInstallClientAppResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_result = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.result = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientinstallclientappresponse() CMsgClientInstallClientAppResponse { +return CMsgClientInstallClientAppResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientinstallclientappresponse(o CMsgClientInstallClientAppResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientinstallclientappresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientInstallClientAppResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientinstallclientappresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUninstallClientApp { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +} +pub fn (o &CMsgClientUninstallClientApp) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +return res +} + +pub fn cmsgclientuninstallclientapp_unpack(buf []byte) ?CMsgClientUninstallClientApp { +mut res := CMsgClientUninstallClientApp{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientuninstallclientapp() CMsgClientUninstallClientApp { +return CMsgClientUninstallClientApp{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientuninstallclientapp(o CMsgClientUninstallClientApp, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientuninstallclientapp(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUninstallClientApp) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientuninstallclientapp_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUninstallClientAppResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +result u32 +has_result bool +} +pub fn (o &CMsgClientUninstallClientAppResponse) pack() []byte { +mut res := []byte{} +if o.has_result { +res << vproto.pack_uint32_field(o.result, 1) +} + +return res +} + +pub fn cmsgclientuninstallclientappresponse_unpack(buf []byte) ?CMsgClientUninstallClientAppResponse { +mut res := CMsgClientUninstallClientAppResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_result = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.result = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientuninstallclientappresponse() CMsgClientUninstallClientAppResponse { +return CMsgClientUninstallClientAppResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientuninstallclientappresponse(o CMsgClientUninstallClientAppResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientuninstallclientappresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUninstallClientAppResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientuninstallclientappresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientSetClientAppUpdateState { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +update bool +has_update bool +} +pub fn (o &CMsgClientSetClientAppUpdateState) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_update { +res << vproto.pack_bool_field(o.update, 2) +} + +return res +} + +pub fn cmsgclientsetclientappupdatestate_unpack(buf []byte) ?CMsgClientSetClientAppUpdateState { +mut res := CMsgClientSetClientAppUpdateState{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_update = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.update = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientsetclientappupdatestate() CMsgClientSetClientAppUpdateState { +return CMsgClientSetClientAppUpdateState{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientsetclientappupdatestate(o CMsgClientSetClientAppUpdateState, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientsetclientappupdatestate(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientSetClientAppUpdateState) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientsetclientappupdatestate_unpack(v)? +return i, unpacked +} +pub struct CMsgClientSetClientAppUpdateStateResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +result u32 +has_result bool +} +pub fn (o &CMsgClientSetClientAppUpdateStateResponse) pack() []byte { +mut res := []byte{} +if o.has_result { +res << vproto.pack_uint32_field(o.result, 1) +} + +return res +} + +pub fn cmsgclientsetclientappupdatestateresponse_unpack(buf []byte) ?CMsgClientSetClientAppUpdateStateResponse { +mut res := CMsgClientSetClientAppUpdateStateResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_result = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.result = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientsetclientappupdatestateresponse() CMsgClientSetClientAppUpdateStateResponse { +return CMsgClientSetClientAppUpdateStateResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientsetclientappupdatestateresponse(o CMsgClientSetClientAppUpdateStateResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientsetclientappupdatestateresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientSetClientAppUpdateStateResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientsetclientappupdatestateresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUFsuploadFileRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +file_size u32 +has_file_size bool +raw_file_size u32 +has_raw_file_size bool +sha_file []byte +has_sha_file bool +time_stamp u64 +has_time_stamp bool +file_name string +has_file_name bool +platforms_to_sync_deprecated u32 +has_platforms_to_sync_deprecated bool +platforms_to_sync u32 +has_platforms_to_sync bool +cell_id u32 +has_cell_id bool +can_encrypt bool +has_can_encrypt bool +} +pub fn (o &CMsgClientUFsuploadFileRequest) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_file_size { +res << vproto.pack_uint32_field(o.file_size, 2) +} + +if o.has_raw_file_size { +res << vproto.pack_uint32_field(o.raw_file_size, 3) +} + +if o.has_sha_file { +res << vproto.pack_bytes_field(o.sha_file, 4) +} + +if o.has_time_stamp { +res << vproto.pack_uint64_field(o.time_stamp, 5) +} + +if o.has_file_name { +res << vproto.pack_string_field(o.file_name, 6) +} + +if o.has_platforms_to_sync_deprecated { +res << vproto.pack_uint32_field(o.platforms_to_sync_deprecated, 7) +} + +if o.has_platforms_to_sync { +res << vproto.pack_uint32_field(o.platforms_to_sync, 8) +} + +if o.has_cell_id { +res << vproto.pack_uint32_field(o.cell_id, 9) +} + +if o.has_can_encrypt { +res << vproto.pack_bool_field(o.can_encrypt, 10) +} + +return res +} + +pub fn cmsgclientufsuploadfilerequest_unpack(buf []byte) ?CMsgClientUFsuploadFileRequest { +mut res := CMsgClientUFsuploadFileRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_file_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.file_size = v +i = ii +} + +3 { +res.has_raw_file_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.raw_file_size = v +i = ii +} + +4 { +res.has_sha_file = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha_file = v +i = ii +} + +5 { +res.has_time_stamp = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.time_stamp = v +i = ii +} + +6 { +res.has_file_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.file_name = v +i = ii +} + +7 { +res.has_platforms_to_sync_deprecated = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.platforms_to_sync_deprecated = v +i = ii +} + +8 { +res.has_platforms_to_sync = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.platforms_to_sync = v +i = ii +} + +9 { +res.has_cell_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cell_id = v +i = ii +} + +10 { +res.has_can_encrypt = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.can_encrypt = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientufsuploadfilerequest() CMsgClientUFsuploadFileRequest { +return CMsgClientUFsuploadFileRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientufsuploadfilerequest(o CMsgClientUFsuploadFileRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientufsuploadfilerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUFsuploadFileRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientufsuploadfilerequest_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUFsuploadFileResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +sha_file []byte +has_sha_file bool +use_http bool +has_use_http bool +http_host string +has_http_host bool +http_url string +has_http_url bool +kv_headers []byte +has_kv_headers bool +use_https bool +has_use_https bool +encrypt_file bool +has_encrypt_file bool +} +pub fn (o &CMsgClientUFsuploadFileResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_sha_file { +res << vproto.pack_bytes_field(o.sha_file, 2) +} + +if o.has_use_http { +res << vproto.pack_bool_field(o.use_http, 3) +} + +if o.has_http_host { +res << vproto.pack_string_field(o.http_host, 4) +} + +if o.has_http_url { +res << vproto.pack_string_field(o.http_url, 5) +} + +if o.has_kv_headers { +res << vproto.pack_bytes_field(o.kv_headers, 6) +} + +if o.has_use_https { +res << vproto.pack_bool_field(o.use_https, 7) +} + +if o.has_encrypt_file { +res << vproto.pack_bool_field(o.encrypt_file, 8) +} + +return res +} + +pub fn cmsgclientufsuploadfileresponse_unpack(buf []byte) ?CMsgClientUFsuploadFileResponse { +mut res := CMsgClientUFsuploadFileResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_sha_file = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha_file = v +i = ii +} + +3 { +res.has_use_http = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.use_http = v +i = ii +} + +4 { +res.has_http_host = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.http_host = v +i = ii +} + +5 { +res.has_http_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.http_url = v +i = ii +} + +6 { +res.has_kv_headers = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.kv_headers = v +i = ii +} + +7 { +res.has_use_https = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.use_https = v +i = ii +} + +8 { +res.has_encrypt_file = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.encrypt_file = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientufsuploadfileresponse() CMsgClientUFsuploadFileResponse { +return CMsgClientUFsuploadFileResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientufsuploadfileresponse(o CMsgClientUFsuploadFileResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientufsuploadfileresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUFsuploadFileResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientufsuploadfileresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUFsuploadCommitFile { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +app_id u32 +has_app_id bool +sha_file []byte +has_sha_file bool +cub_file u32 +has_cub_file bool +file_name string +has_file_name bool +} +pub fn (o &CMsgClientUFsuploadCommitFile) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 2) +} + +if o.has_sha_file { +res << vproto.pack_bytes_field(o.sha_file, 3) +} + +if o.has_cub_file { +res << vproto.pack_uint32_field(o.cub_file, 4) +} + +if o.has_file_name { +res << vproto.pack_string_field(o.file_name, 5) +} + +return res +} + +pub fn cmsgclientufsuploadcommitfile_unpack(buf []byte) ?CMsgClientUFsuploadCommitFile { +mut res := CMsgClientUFsuploadCommitFile{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +3 { +res.has_sha_file = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha_file = v +i = ii +} + +4 { +res.has_cub_file = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cub_file = v +i = ii +} + +5 { +res.has_file_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.file_name = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientufsuploadcommitfile() CMsgClientUFsuploadCommitFile { +return CMsgClientUFsuploadCommitFile{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientufsuploadcommitfile(o CMsgClientUFsuploadCommitFile, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientufsuploadcommitfile(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUFsuploadCommitFile) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientufsuploadcommitfile_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUFsuploadCommit { +mut: +unknown_fields []vproto.UnknownField +pub mut: +files []CMsgClientUFsuploadCommitFile +} +pub fn (o &CMsgClientUFsuploadCommit) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.files { +res << zzz_vproto_internal_pack_cmsgclientufsuploadcommitfile(x, 1) +} + +return res +} + +pub fn cmsgclientufsuploadcommit_unpack(buf []byte) ?CMsgClientUFsuploadCommit { +mut res := CMsgClientUFsuploadCommit{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientufsuploadcommitfile(cur_buf, tag_wiretype.wire_type)? +res.files << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientufsuploadcommit() CMsgClientUFsuploadCommit { +return CMsgClientUFsuploadCommit{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientufsuploadcommit(o CMsgClientUFsuploadCommit, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientufsuploadcommit(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUFsuploadCommit) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientufsuploadcommit_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUFsuploadCommitResponseFile { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +app_id u32 +has_app_id bool +sha_file []byte +has_sha_file bool +} +pub fn (o &CMsgClientUFsuploadCommitResponseFile) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 2) +} + +if o.has_sha_file { +res << vproto.pack_bytes_field(o.sha_file, 3) +} + +return res +} + +pub fn cmsgclientufsuploadcommitresponsefile_unpack(buf []byte) ?CMsgClientUFsuploadCommitResponseFile { +mut res := CMsgClientUFsuploadCommitResponseFile{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +3 { +res.has_sha_file = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha_file = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientufsuploadcommitresponsefile() CMsgClientUFsuploadCommitResponseFile { +return CMsgClientUFsuploadCommitResponseFile{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientufsuploadcommitresponsefile(o CMsgClientUFsuploadCommitResponseFile, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientufsuploadcommitresponsefile(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUFsuploadCommitResponseFile) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientufsuploadcommitresponsefile_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUFsuploadCommitResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +files []CMsgClientUFsuploadCommitResponseFile +} +pub fn (o &CMsgClientUFsuploadCommitResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.files { +res << zzz_vproto_internal_pack_cmsgclientufsuploadcommitresponsefile(x, 1) +} + +return res +} + +pub fn cmsgclientufsuploadcommitresponse_unpack(buf []byte) ?CMsgClientUFsuploadCommitResponse { +mut res := CMsgClientUFsuploadCommitResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientufsuploadcommitresponsefile(cur_buf, tag_wiretype.wire_type)? +res.files << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientufsuploadcommitresponse() CMsgClientUFsuploadCommitResponse { +return CMsgClientUFsuploadCommitResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientufsuploadcommitresponse(o CMsgClientUFsuploadCommitResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientufsuploadcommitresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUFsuploadCommitResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientufsuploadcommitresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUFsfileChunk { +mut: +unknown_fields []vproto.UnknownField +pub mut: +sha_file []byte +has_sha_file bool +file_start u32 +has_file_start bool +data []byte +has_data bool +} +pub fn (o &CMsgClientUFsfileChunk) pack() []byte { +mut res := []byte{} +if o.has_sha_file { +res << vproto.pack_bytes_field(o.sha_file, 1) +} + +if o.has_file_start { +res << vproto.pack_uint32_field(o.file_start, 2) +} + +if o.has_data { +res << vproto.pack_bytes_field(o.data, 3) +} + +return res +} + +pub fn cmsgclientufsfilechunk_unpack(buf []byte) ?CMsgClientUFsfileChunk { +mut res := CMsgClientUFsfileChunk{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_sha_file = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha_file = v +i = ii +} + +2 { +res.has_file_start = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.file_start = v +i = ii +} + +3 { +res.has_data = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.data = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientufsfilechunk() CMsgClientUFsfileChunk { +return CMsgClientUFsfileChunk{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientufsfilechunk(o CMsgClientUFsfileChunk, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientufsfilechunk(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUFsfileChunk) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientufsfilechunk_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUFstransferHeartbeat { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CMsgClientUFstransferHeartbeat) pack() []byte { +res := []byte{} +return res +} + +pub fn cmsgclientufstransferheartbeat_unpack(buf []byte) ?CMsgClientUFstransferHeartbeat { +res := CMsgClientUFstransferHeartbeat{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientufstransferheartbeat() CMsgClientUFstransferHeartbeat { +return CMsgClientUFstransferHeartbeat{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientufstransferheartbeat(o CMsgClientUFstransferHeartbeat, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientufstransferheartbeat(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUFstransferHeartbeat) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientufstransferheartbeat_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUFsuploadFileFinished { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +sha_file []byte +has_sha_file bool +} +pub fn (o &CMsgClientUFsuploadFileFinished) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_sha_file { +res << vproto.pack_bytes_field(o.sha_file, 2) +} + +return res +} + +pub fn cmsgclientufsuploadfilefinished_unpack(buf []byte) ?CMsgClientUFsuploadFileFinished { +mut res := CMsgClientUFsuploadFileFinished{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_sha_file = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha_file = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientufsuploadfilefinished() CMsgClientUFsuploadFileFinished { +return CMsgClientUFsuploadFileFinished{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientufsuploadfilefinished(o CMsgClientUFsuploadFileFinished, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientufsuploadfilefinished(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUFsuploadFileFinished) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientufsuploadfilefinished_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUFsdeleteFileRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +file_name string +has_file_name bool +is_explicit_delete bool +has_is_explicit_delete bool +} +pub fn (o &CMsgClientUFsdeleteFileRequest) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_file_name { +res << vproto.pack_string_field(o.file_name, 2) +} + +if o.has_is_explicit_delete { +res << vproto.pack_bool_field(o.is_explicit_delete, 3) +} + +return res +} + +pub fn cmsgclientufsdeletefilerequest_unpack(buf []byte) ?CMsgClientUFsdeleteFileRequest { +mut res := CMsgClientUFsdeleteFileRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_file_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.file_name = v +i = ii +} + +3 { +res.has_is_explicit_delete = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_explicit_delete = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientufsdeletefilerequest() CMsgClientUFsdeleteFileRequest { +return CMsgClientUFsdeleteFileRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientufsdeletefilerequest(o CMsgClientUFsdeleteFileRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientufsdeletefilerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUFsdeleteFileRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientufsdeletefilerequest_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUFsdeleteFileResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +file_name string +has_file_name bool +} +pub fn (o &CMsgClientUFsdeleteFileResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_file_name { +res << vproto.pack_string_field(o.file_name, 2) +} + +return res +} + +pub fn cmsgclientufsdeletefileresponse_unpack(buf []byte) ?CMsgClientUFsdeleteFileResponse { +mut res := CMsgClientUFsdeleteFileResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_file_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.file_name = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientufsdeletefileresponse() CMsgClientUFsdeleteFileResponse { +return CMsgClientUFsdeleteFileResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientufsdeletefileresponse(o CMsgClientUFsdeleteFileResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientufsdeletefileresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUFsdeleteFileResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientufsdeletefileresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUFsgetFileListForApp { +mut: +unknown_fields []vproto.UnknownField +pub mut: +apps_to_query []u32 +send_path_prefixes bool +has_send_path_prefixes bool +} +pub fn (o &CMsgClientUFsgetFileListForApp) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.apps_to_query { +res << vproto.pack_uint32_field(x, 1) +} + +if o.has_send_path_prefixes { +res << vproto.pack_bool_field(o.send_path_prefixes, 2) +} + +return res +} + +pub fn cmsgclientufsgetfilelistforapp_unpack(buf []byte) ?CMsgClientUFsgetFileListForApp { +mut res := CMsgClientUFsgetFileListForApp{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.apps_to_query << v +i = ii +} + +2 { +res.has_send_path_prefixes = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.send_path_prefixes = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientufsgetfilelistforapp() CMsgClientUFsgetFileListForApp { +return CMsgClientUFsgetFileListForApp{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientufsgetfilelistforapp(o CMsgClientUFsgetFileListForApp, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientufsgetfilelistforapp(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUFsgetFileListForApp) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientufsgetfilelistforapp_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUFsgetFileListForAppResponseFile { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +file_name string +has_file_name bool +sha_file []byte +has_sha_file bool +time_stamp u64 +has_time_stamp bool +raw_file_size u32 +has_raw_file_size bool +is_explicit_delete bool +has_is_explicit_delete bool +platforms_to_sync u32 +has_platforms_to_sync bool +path_prefix_index u32 +has_path_prefix_index bool +} +pub fn (o &CMsgClientUFsgetFileListForAppResponseFile) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_file_name { +res << vproto.pack_string_field(o.file_name, 2) +} + +if o.has_sha_file { +res << vproto.pack_bytes_field(o.sha_file, 3) +} + +if o.has_time_stamp { +res << vproto.pack_uint64_field(o.time_stamp, 4) +} + +if o.has_raw_file_size { +res << vproto.pack_uint32_field(o.raw_file_size, 5) +} + +if o.has_is_explicit_delete { +res << vproto.pack_bool_field(o.is_explicit_delete, 6) +} + +if o.has_platforms_to_sync { +res << vproto.pack_uint32_field(o.platforms_to_sync, 7) +} + +if o.has_path_prefix_index { +res << vproto.pack_uint32_field(o.path_prefix_index, 8) +} + +return res +} + +pub fn cmsgclientufsgetfilelistforappresponsefile_unpack(buf []byte) ?CMsgClientUFsgetFileListForAppResponseFile { +mut res := CMsgClientUFsgetFileListForAppResponseFile{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_file_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.file_name = v +i = ii +} + +3 { +res.has_sha_file = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha_file = v +i = ii +} + +4 { +res.has_time_stamp = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.time_stamp = v +i = ii +} + +5 { +res.has_raw_file_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.raw_file_size = v +i = ii +} + +6 { +res.has_is_explicit_delete = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_explicit_delete = v +i = ii +} + +7 { +res.has_platforms_to_sync = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.platforms_to_sync = v +i = ii +} + +8 { +res.has_path_prefix_index = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.path_prefix_index = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientufsgetfilelistforappresponsefile() CMsgClientUFsgetFileListForAppResponseFile { +return CMsgClientUFsgetFileListForAppResponseFile{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientufsgetfilelistforappresponsefile(o CMsgClientUFsgetFileListForAppResponseFile, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientufsgetfilelistforappresponsefile(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUFsgetFileListForAppResponseFile) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientufsgetfilelistforappresponsefile_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUFsgetFileListForAppResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +files []CMsgClientUFsgetFileListForAppResponseFile +path_prefixes []string +} +pub fn (o &CMsgClientUFsgetFileListForAppResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.files { +res << zzz_vproto_internal_pack_cmsgclientufsgetfilelistforappresponsefile(x, 1) +} + +// [packed=false] +for _, x in o.path_prefixes { +res << vproto.pack_string_field(x, 2) +} + +return res +} + +pub fn cmsgclientufsgetfilelistforappresponse_unpack(buf []byte) ?CMsgClientUFsgetFileListForAppResponse { +mut res := CMsgClientUFsgetFileListForAppResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientufsgetfilelistforappresponsefile(cur_buf, tag_wiretype.wire_type)? +res.files << v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.path_prefixes << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientufsgetfilelistforappresponse() CMsgClientUFsgetFileListForAppResponse { +return CMsgClientUFsgetFileListForAppResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientufsgetfilelistforappresponse(o CMsgClientUFsgetFileListForAppResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientufsgetfilelistforappresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUFsgetFileListForAppResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientufsgetfilelistforappresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUFsdownloadRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +file_name string +has_file_name bool +can_handle_http bool +has_can_handle_http bool +} +pub fn (o &CMsgClientUFsdownloadRequest) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_file_name { +res << vproto.pack_string_field(o.file_name, 2) +} + +if o.has_can_handle_http { +res << vproto.pack_bool_field(o.can_handle_http, 3) +} + +return res +} + +pub fn cmsgclientufsdownloadrequest_unpack(buf []byte) ?CMsgClientUFsdownloadRequest { +mut res := CMsgClientUFsdownloadRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_file_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.file_name = v +i = ii +} + +3 { +res.has_can_handle_http = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.can_handle_http = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientufsdownloadrequest() CMsgClientUFsdownloadRequest { +return CMsgClientUFsdownloadRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientufsdownloadrequest(o CMsgClientUFsdownloadRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientufsdownloadrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUFsdownloadRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientufsdownloadrequest_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUFsdownloadResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +app_id u32 +has_app_id bool +file_size u32 +has_file_size bool +raw_file_size u32 +has_raw_file_size bool +sha_file []byte +has_sha_file bool +time_stamp u64 +has_time_stamp bool +is_explicit_delete bool +has_is_explicit_delete bool +use_http bool +has_use_http bool +http_host string +has_http_host bool +http_url string +has_http_url bool +kv_headers []byte +has_kv_headers bool +use_https bool +has_use_https bool +encrypted bool +has_encrypted bool +} +pub fn (o &CMsgClientUFsdownloadResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 2) +} + +if o.has_file_size { +res << vproto.pack_uint32_field(o.file_size, 3) +} + +if o.has_raw_file_size { +res << vproto.pack_uint32_field(o.raw_file_size, 4) +} + +if o.has_sha_file { +res << vproto.pack_bytes_field(o.sha_file, 5) +} + +if o.has_time_stamp { +res << vproto.pack_uint64_field(o.time_stamp, 6) +} + +if o.has_is_explicit_delete { +res << vproto.pack_bool_field(o.is_explicit_delete, 7) +} + +if o.has_use_http { +res << vproto.pack_bool_field(o.use_http, 8) +} + +if o.has_http_host { +res << vproto.pack_string_field(o.http_host, 9) +} + +if o.has_http_url { +res << vproto.pack_string_field(o.http_url, 10) +} + +if o.has_kv_headers { +res << vproto.pack_bytes_field(o.kv_headers, 11) +} + +if o.has_use_https { +res << vproto.pack_bool_field(o.use_https, 12) +} + +if o.has_encrypted { +res << vproto.pack_bool_field(o.encrypted, 13) +} + +return res +} + +pub fn cmsgclientufsdownloadresponse_unpack(buf []byte) ?CMsgClientUFsdownloadResponse { +mut res := CMsgClientUFsdownloadResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +3 { +res.has_file_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.file_size = v +i = ii +} + +4 { +res.has_raw_file_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.raw_file_size = v +i = ii +} + +5 { +res.has_sha_file = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha_file = v +i = ii +} + +6 { +res.has_time_stamp = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.time_stamp = v +i = ii +} + +7 { +res.has_is_explicit_delete = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_explicit_delete = v +i = ii +} + +8 { +res.has_use_http = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.use_http = v +i = ii +} + +9 { +res.has_http_host = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.http_host = v +i = ii +} + +10 { +res.has_http_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.http_url = v +i = ii +} + +11 { +res.has_kv_headers = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.kv_headers = v +i = ii +} + +12 { +res.has_use_https = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.use_https = v +i = ii +} + +13 { +res.has_encrypted = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.encrypted = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientufsdownloadresponse() CMsgClientUFsdownloadResponse { +return CMsgClientUFsdownloadResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientufsdownloadresponse(o CMsgClientUFsdownloadResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientufsdownloadresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUFsdownloadResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientufsdownloadresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUFsloginRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +protocol_version u32 +has_protocol_version bool +am_session_token u64 +has_am_session_token bool +apps []u32 +} +pub fn (o &CMsgClientUFsloginRequest) pack() []byte { +mut res := []byte{} +if o.has_protocol_version { +res << vproto.pack_uint32_field(o.protocol_version, 1) +} + +if o.has_am_session_token { +res << vproto.pack_uint64_field(o.am_session_token, 2) +} + +// [packed=false] +for _, x in o.apps { +res << vproto.pack_uint32_field(x, 3) +} + +return res +} + +pub fn cmsgclientufsloginrequest_unpack(buf []byte) ?CMsgClientUFsloginRequest { +mut res := CMsgClientUFsloginRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_protocol_version = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.protocol_version = v +i = ii +} + +2 { +res.has_am_session_token = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.am_session_token = v +i = ii +} + +3 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.apps << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientufsloginrequest() CMsgClientUFsloginRequest { +return CMsgClientUFsloginRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientufsloginrequest(o CMsgClientUFsloginRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientufsloginrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUFsloginRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientufsloginrequest_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUFsloginResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +} +pub fn (o &CMsgClientUFsloginResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +return res +} + +pub fn cmsgclientufsloginresponse_unpack(buf []byte) ?CMsgClientUFsloginResponse { +mut res := CMsgClientUFsloginResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientufsloginresponse() CMsgClientUFsloginResponse { +return CMsgClientUFsloginResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientufsloginresponse(o CMsgClientUFsloginResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientufsloginresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUFsloginResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientufsloginresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRequestEncryptedAppTicket { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +userdata []byte +has_userdata bool +} +pub fn (o &CMsgClientRequestEncryptedAppTicket) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_userdata { +res << vproto.pack_bytes_field(o.userdata, 2) +} + +return res +} + +pub fn cmsgclientrequestencryptedappticket_unpack(buf []byte) ?CMsgClientRequestEncryptedAppTicket { +mut res := CMsgClientRequestEncryptedAppTicket{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_userdata = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.userdata = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientrequestencryptedappticket() CMsgClientRequestEncryptedAppTicket { +return CMsgClientRequestEncryptedAppTicket{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientrequestencryptedappticket(o CMsgClientRequestEncryptedAppTicket, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientrequestencryptedappticket(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRequestEncryptedAppTicket) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientrequestencryptedappticket_unpack(v)? +return i, unpacked +} +pub struct CMsgClientRequestEncryptedAppTicketResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +eresult int +has_eresult bool +encrypted_app_ticket EncryptedAppTicket +has_encrypted_app_ticket bool +} +pub fn (o &CMsgClientRequestEncryptedAppTicketResponse) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 2) +} + +if o.has_encrypted_app_ticket { +res << zzz_vproto_internal_pack_encryptedappticket(o.encrypted_app_ticket, 3) +} + +return res +} + +pub fn cmsgclientrequestencryptedappticketresponse_unpack(buf []byte) ?CMsgClientRequestEncryptedAppTicketResponse { +mut res := CMsgClientRequestEncryptedAppTicketResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +3 { +res.has_encrypted_app_ticket = true +ii, v := zzz_vproto_internal_unpack_encryptedappticket(cur_buf, tag_wiretype.wire_type)? +res.encrypted_app_ticket = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientrequestencryptedappticketresponse() CMsgClientRequestEncryptedAppTicketResponse { +return CMsgClientRequestEncryptedAppTicketResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientrequestencryptedappticketresponse(o CMsgClientRequestEncryptedAppTicketResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientrequestencryptedappticketresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientRequestEncryptedAppTicketResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientrequestencryptedappticketresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientWalletInfoUpdate { +mut: +unknown_fields []vproto.UnknownField +pub mut: +has_wallet bool +has_has_wallet bool +balance int +has_balance bool +currency int +has_currency bool +balance_delayed int +has_balance_delayed bool +balance64 i64 +has_balance64 bool +balance64_delayed i64 +has_balance64_delayed bool +} +pub fn (o &CMsgClientWalletInfoUpdate) pack() []byte { +mut res := []byte{} +if o.has_has_wallet { +res << vproto.pack_bool_field(o.has_wallet, 1) +} + +if o.has_balance { +res << vproto.pack_int32_field(o.balance, 2) +} + +if o.has_currency { +res << vproto.pack_int32_field(o.currency, 3) +} + +if o.has_balance_delayed { +res << vproto.pack_int32_field(o.balance_delayed, 4) +} + +if o.has_balance64 { +res << vproto.pack_int64_field(o.balance64, 5) +} + +if o.has_balance64_delayed { +res << vproto.pack_int64_field(o.balance64_delayed, 6) +} + +return res +} + +pub fn cmsgclientwalletinfoupdate_unpack(buf []byte) ?CMsgClientWalletInfoUpdate { +mut res := CMsgClientWalletInfoUpdate{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_has_wallet = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.has_wallet = v +i = ii +} + +2 { +res.has_balance = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.balance = v +i = ii +} + +3 { +res.has_currency = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.currency = v +i = ii +} + +4 { +res.has_balance_delayed = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.balance_delayed = v +i = ii +} + +5 { +res.has_balance64 = true +ii, v := vproto.unpack_int64_field(cur_buf, tag_wiretype.wire_type)? +res.balance64 = v +i = ii +} + +6 { +res.has_balance64_delayed = true +ii, v := vproto.unpack_int64_field(cur_buf, tag_wiretype.wire_type)? +res.balance64_delayed = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientwalletinfoupdate() CMsgClientWalletInfoUpdate { +return CMsgClientWalletInfoUpdate{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientwalletinfoupdate(o CMsgClientWalletInfoUpdate, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientwalletinfoupdate(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientWalletInfoUpdate) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientwalletinfoupdate_unpack(v)? +return i, unpacked +} +pub struct CMsgClientAppInfoUpdate { +mut: +unknown_fields []vproto.UnknownField +pub mut: +last_changenumber u32 +has_last_changenumber bool +send_changelist bool +has_send_changelist bool +} +pub fn (o &CMsgClientAppInfoUpdate) pack() []byte { +mut res := []byte{} +if o.has_last_changenumber { +res << vproto.pack_uint32_field(o.last_changenumber, 1) +} + +if o.has_send_changelist { +res << vproto.pack_bool_field(o.send_changelist, 2) +} + +return res +} + +pub fn cmsgclientappinfoupdate_unpack(buf []byte) ?CMsgClientAppInfoUpdate { +mut res := CMsgClientAppInfoUpdate{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_last_changenumber = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_changenumber = v +i = ii +} + +2 { +res.has_send_changelist = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.send_changelist = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientappinfoupdate() CMsgClientAppInfoUpdate { +return CMsgClientAppInfoUpdate{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientappinfoupdate(o CMsgClientAppInfoUpdate, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientappinfoupdate(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientAppInfoUpdate) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientappinfoupdate_unpack(v)? +return i, unpacked +} +pub struct CMsgClientAppInfoChanges { +mut: +unknown_fields []vproto.UnknownField +pub mut: +current_change_number u32 +has_current_change_number bool +force_full_update bool +has_force_full_update bool +appids []u32 +} +pub fn (o &CMsgClientAppInfoChanges) pack() []byte { +mut res := []byte{} +if o.has_current_change_number { +res << vproto.pack_uint32_field(o.current_change_number, 1) +} + +if o.has_force_full_update { +res << vproto.pack_bool_field(o.force_full_update, 2) +} + +// [packed=false] +for _, x in o.appids { +res << vproto.pack_uint32_field(x, 3) +} + +return res +} + +pub fn cmsgclientappinfochanges_unpack(buf []byte) ?CMsgClientAppInfoChanges { +mut res := CMsgClientAppInfoChanges{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_current_change_number = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.current_change_number = v +i = ii +} + +2 { +res.has_force_full_update = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.force_full_update = v +i = ii +} + +3 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientappinfochanges() CMsgClientAppInfoChanges { +return CMsgClientAppInfoChanges{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientappinfochanges(o CMsgClientAppInfoChanges, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientappinfochanges(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientAppInfoChanges) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientappinfochanges_unpack(v)? +return i, unpacked +} +pub struct CMsgClientAppInfoRequestApp { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +section_flags u32 +has_section_flags bool +section_crc []u32 +} +pub fn (o &CMsgClientAppInfoRequestApp) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_section_flags { +res << vproto.pack_uint32_field(o.section_flags, 2) +} + +// [packed=false] +for _, x in o.section_crc { +res << vproto.pack_uint32_field(x, 3) +} + +return res +} + +pub fn cmsgclientappinforequestapp_unpack(buf []byte) ?CMsgClientAppInfoRequestApp { +mut res := CMsgClientAppInfoRequestApp{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_section_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.section_flags = v +i = ii +} + +3 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.section_crc << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientappinforequestapp() CMsgClientAppInfoRequestApp { +return CMsgClientAppInfoRequestApp{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientappinforequestapp(o CMsgClientAppInfoRequestApp, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientappinforequestapp(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientAppInfoRequestApp) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientappinforequestapp_unpack(v)? +return i, unpacked +} +pub struct CMsgClientAppInfoRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +apps []CMsgClientAppInfoRequestApp +supports_batches bool +has_supports_batches bool +} +pub fn (o &CMsgClientAppInfoRequest) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.apps { +res << zzz_vproto_internal_pack_cmsgclientappinforequestapp(x, 1) +} + +if o.has_supports_batches { +res << vproto.pack_bool_field(o.supports_batches, 2) +} + +return res +} + +pub fn cmsgclientappinforequest_unpack(buf []byte) ?CMsgClientAppInfoRequest { +mut res := CMsgClientAppInfoRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientappinforequestapp(cur_buf, tag_wiretype.wire_type)? +res.apps << v +i = ii +} + +2 { +res.has_supports_batches = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.supports_batches = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientappinforequest() CMsgClientAppInfoRequest { +return CMsgClientAppInfoRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientappinforequest(o CMsgClientAppInfoRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientappinforequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientAppInfoRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientappinforequest_unpack(v)? +return i, unpacked +} +pub struct CMsgClientAppInfoResponseAppSection { +mut: +unknown_fields []vproto.UnknownField +pub mut: +section_id u32 +has_section_id bool +section_kv []byte +has_section_kv bool +} +pub fn (o &CMsgClientAppInfoResponseAppSection) pack() []byte { +mut res := []byte{} +if o.has_section_id { +res << vproto.pack_uint32_field(o.section_id, 1) +} + +if o.has_section_kv { +res << vproto.pack_bytes_field(o.section_kv, 2) +} + +return res +} + +pub fn cmsgclientappinforesponseappsection_unpack(buf []byte) ?CMsgClientAppInfoResponseAppSection { +mut res := CMsgClientAppInfoResponseAppSection{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_section_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.section_id = v +i = ii +} + +2 { +res.has_section_kv = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.section_kv = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientappinforesponseappsection() CMsgClientAppInfoResponseAppSection { +return CMsgClientAppInfoResponseAppSection{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientappinforesponseappsection(o CMsgClientAppInfoResponseAppSection, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientappinforesponseappsection(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientAppInfoResponseAppSection) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientappinforesponseappsection_unpack(v)? +return i, unpacked +} +pub struct CMsgClientAppInfoResponseApp { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +change_number u32 +has_change_number bool +sections []CMsgClientAppInfoResponseAppSection +} +pub fn (o &CMsgClientAppInfoResponseApp) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_change_number { +res << vproto.pack_uint32_field(o.change_number, 2) +} + +// [packed=false] +for _, x in o.sections { +res << zzz_vproto_internal_pack_cmsgclientappinforesponseappsection(x, 3) +} + +return res +} + +pub fn cmsgclientappinforesponseapp_unpack(buf []byte) ?CMsgClientAppInfoResponseApp { +mut res := CMsgClientAppInfoResponseApp{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_change_number = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.change_number = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientappinforesponseappsection(cur_buf, tag_wiretype.wire_type)? +res.sections << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientappinforesponseapp() CMsgClientAppInfoResponseApp { +return CMsgClientAppInfoResponseApp{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientappinforesponseapp(o CMsgClientAppInfoResponseApp, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientappinforesponseapp(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientAppInfoResponseApp) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientappinforesponseapp_unpack(v)? +return i, unpacked +} +pub struct CMsgClientAppInfoResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +apps []CMsgClientAppInfoResponseApp +apps_unknown []u32 +apps_pending u32 +has_apps_pending bool +} +pub fn (o &CMsgClientAppInfoResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.apps { +res << zzz_vproto_internal_pack_cmsgclientappinforesponseapp(x, 1) +} + +// [packed=false] +for _, x in o.apps_unknown { +res << vproto.pack_uint32_field(x, 2) +} + +if o.has_apps_pending { +res << vproto.pack_uint32_field(o.apps_pending, 3) +} + +return res +} + +pub fn cmsgclientappinforesponse_unpack(buf []byte) ?CMsgClientAppInfoResponse { +mut res := CMsgClientAppInfoResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientappinforesponseapp(cur_buf, tag_wiretype.wire_type)? +res.apps << v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.apps_unknown << v +i = ii +} + +3 { +res.has_apps_pending = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.apps_pending = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientappinforesponse() CMsgClientAppInfoResponse { +return CMsgClientAppInfoResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientappinforesponse(o CMsgClientAppInfoResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientappinforesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientAppInfoResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientappinforesponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientPackageInfoRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +package_ids []u32 +meta_data_only bool +has_meta_data_only bool +} +pub fn (o &CMsgClientPackageInfoRequest) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.package_ids { +res << vproto.pack_uint32_field(x, 1) +} + +if o.has_meta_data_only { +res << vproto.pack_bool_field(o.meta_data_only, 2) +} + +return res +} + +pub fn cmsgclientpackageinforequest_unpack(buf []byte) ?CMsgClientPackageInfoRequest { +mut res := CMsgClientPackageInfoRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.package_ids << v +i = ii +} + +2 { +res.has_meta_data_only = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.meta_data_only = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientpackageinforequest() CMsgClientPackageInfoRequest { +return CMsgClientPackageInfoRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientpackageinforequest(o CMsgClientPackageInfoRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientpackageinforequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientPackageInfoRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientpackageinforequest_unpack(v)? +return i, unpacked +} +pub struct CMsgClientPackageInfoResponsePackage { +mut: +unknown_fields []vproto.UnknownField +pub mut: +package_id u32 +has_package_id bool +change_number u32 +has_change_number bool +sha []byte +has_sha bool +buffer []byte +has_buffer bool +} +pub fn (o &CMsgClientPackageInfoResponsePackage) pack() []byte { +mut res := []byte{} +if o.has_package_id { +res << vproto.pack_uint32_field(o.package_id, 1) +} + +if o.has_change_number { +res << vproto.pack_uint32_field(o.change_number, 2) +} + +if o.has_sha { +res << vproto.pack_bytes_field(o.sha, 3) +} + +if o.has_buffer { +res << vproto.pack_bytes_field(o.buffer, 4) +} + +return res +} + +pub fn cmsgclientpackageinforesponsepackage_unpack(buf []byte) ?CMsgClientPackageInfoResponsePackage { +mut res := CMsgClientPackageInfoResponsePackage{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_package_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.package_id = v +i = ii +} + +2 { +res.has_change_number = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.change_number = v +i = ii +} + +3 { +res.has_sha = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha = v +i = ii +} + +4 { +res.has_buffer = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.buffer = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientpackageinforesponsepackage() CMsgClientPackageInfoResponsePackage { +return CMsgClientPackageInfoResponsePackage{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientpackageinforesponsepackage(o CMsgClientPackageInfoResponsePackage, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientpackageinforesponsepackage(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientPackageInfoResponsePackage) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientpackageinforesponsepackage_unpack(v)? +return i, unpacked +} +pub struct CMsgClientPackageInfoResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +packages []CMsgClientPackageInfoResponsePackage +packages_unknown []u32 +packages_pending u32 +has_packages_pending bool +} +pub fn (o &CMsgClientPackageInfoResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.packages { +res << zzz_vproto_internal_pack_cmsgclientpackageinforesponsepackage(x, 1) +} + +// [packed=false] +for _, x in o.packages_unknown { +res << vproto.pack_uint32_field(x, 2) +} + +if o.has_packages_pending { +res << vproto.pack_uint32_field(o.packages_pending, 3) +} + +return res +} + +pub fn cmsgclientpackageinforesponse_unpack(buf []byte) ?CMsgClientPackageInfoResponse { +mut res := CMsgClientPackageInfoResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientpackageinforesponsepackage(cur_buf, tag_wiretype.wire_type)? +res.packages << v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.packages_unknown << v +i = ii +} + +3 { +res.has_packages_pending = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.packages_pending = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientpackageinforesponse() CMsgClientPackageInfoResponse { +return CMsgClientPackageInfoResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientpackageinforesponse(o CMsgClientPackageInfoResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientpackageinforesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientPackageInfoResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientpackageinforesponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientPIcschangesSinceRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +since_change_number u32 +has_since_change_number bool +send_app_info_changes bool +has_send_app_info_changes bool +send_package_info_changes bool +has_send_package_info_changes bool +num_app_info_cached u32 +has_num_app_info_cached bool +num_package_info_cached u32 +has_num_package_info_cached bool +} +pub fn (o &CMsgClientPIcschangesSinceRequest) pack() []byte { +mut res := []byte{} +if o.has_since_change_number { +res << vproto.pack_uint32_field(o.since_change_number, 1) +} + +if o.has_send_app_info_changes { +res << vproto.pack_bool_field(o.send_app_info_changes, 2) +} + +if o.has_send_package_info_changes { +res << vproto.pack_bool_field(o.send_package_info_changes, 3) +} + +if o.has_num_app_info_cached { +res << vproto.pack_uint32_field(o.num_app_info_cached, 4) +} + +if o.has_num_package_info_cached { +res << vproto.pack_uint32_field(o.num_package_info_cached, 5) +} + +return res +} + +pub fn cmsgclientpicschangessincerequest_unpack(buf []byte) ?CMsgClientPIcschangesSinceRequest { +mut res := CMsgClientPIcschangesSinceRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_since_change_number = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.since_change_number = v +i = ii +} + +2 { +res.has_send_app_info_changes = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.send_app_info_changes = v +i = ii +} + +3 { +res.has_send_package_info_changes = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.send_package_info_changes = v +i = ii +} + +4 { +res.has_num_app_info_cached = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.num_app_info_cached = v +i = ii +} + +5 { +res.has_num_package_info_cached = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.num_package_info_cached = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientpicschangessincerequest() CMsgClientPIcschangesSinceRequest { +return CMsgClientPIcschangesSinceRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientpicschangessincerequest(o CMsgClientPIcschangesSinceRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientpicschangessincerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientPIcschangesSinceRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientpicschangessincerequest_unpack(v)? +return i, unpacked +} +pub struct CMsgClientPIcschangesSinceResponsePackageChange { +mut: +unknown_fields []vproto.UnknownField +pub mut: +packageid u32 +has_packageid bool +change_number u32 +has_change_number bool +needs_token bool +has_needs_token bool +} +pub fn (o &CMsgClientPIcschangesSinceResponsePackageChange) pack() []byte { +mut res := []byte{} +if o.has_packageid { +res << vproto.pack_uint32_field(o.packageid, 1) +} + +if o.has_change_number { +res << vproto.pack_uint32_field(o.change_number, 2) +} + +if o.has_needs_token { +res << vproto.pack_bool_field(o.needs_token, 3) +} + +return res +} + +pub fn cmsgclientpicschangessinceresponsepackagechange_unpack(buf []byte) ?CMsgClientPIcschangesSinceResponsePackageChange { +mut res := CMsgClientPIcschangesSinceResponsePackageChange{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_packageid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.packageid = v +i = ii +} + +2 { +res.has_change_number = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.change_number = v +i = ii +} + +3 { +res.has_needs_token = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.needs_token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientpicschangessinceresponsepackagechange() CMsgClientPIcschangesSinceResponsePackageChange { +return CMsgClientPIcschangesSinceResponsePackageChange{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientpicschangessinceresponsepackagechange(o CMsgClientPIcschangesSinceResponsePackageChange, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientpicschangessinceresponsepackagechange(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientPIcschangesSinceResponsePackageChange) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientpicschangessinceresponsepackagechange_unpack(v)? +return i, unpacked +} +pub struct CMsgClientPIcschangesSinceResponseAppChange { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +change_number u32 +has_change_number bool +needs_token bool +has_needs_token bool +} +pub fn (o &CMsgClientPIcschangesSinceResponseAppChange) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_change_number { +res << vproto.pack_uint32_field(o.change_number, 2) +} + +if o.has_needs_token { +res << vproto.pack_bool_field(o.needs_token, 3) +} + +return res +} + +pub fn cmsgclientpicschangessinceresponseappchange_unpack(buf []byte) ?CMsgClientPIcschangesSinceResponseAppChange { +mut res := CMsgClientPIcschangesSinceResponseAppChange{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_change_number = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.change_number = v +i = ii +} + +3 { +res.has_needs_token = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.needs_token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientpicschangessinceresponseappchange() CMsgClientPIcschangesSinceResponseAppChange { +return CMsgClientPIcschangesSinceResponseAppChange{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientpicschangessinceresponseappchange(o CMsgClientPIcschangesSinceResponseAppChange, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientpicschangessinceresponseappchange(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientPIcschangesSinceResponseAppChange) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientpicschangessinceresponseappchange_unpack(v)? +return i, unpacked +} +pub struct CMsgClientPIcschangesSinceResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +current_change_number u32 +has_current_change_number bool +since_change_number u32 +has_since_change_number bool +force_full_update bool +has_force_full_update bool +package_changes []CMsgClientPIcschangesSinceResponsePackageChange +app_changes []CMsgClientPIcschangesSinceResponseAppChange +force_full_app_update bool +has_force_full_app_update bool +force_full_package_update bool +has_force_full_package_update bool +} +pub fn (o &CMsgClientPIcschangesSinceResponse) pack() []byte { +mut res := []byte{} +if o.has_current_change_number { +res << vproto.pack_uint32_field(o.current_change_number, 1) +} + +if o.has_since_change_number { +res << vproto.pack_uint32_field(o.since_change_number, 2) +} + +if o.has_force_full_update { +res << vproto.pack_bool_field(o.force_full_update, 3) +} + +// [packed=false] +for _, x in o.package_changes { +res << zzz_vproto_internal_pack_cmsgclientpicschangessinceresponsepackagechange(x, 4) +} + +// [packed=false] +for _, x in o.app_changes { +res << zzz_vproto_internal_pack_cmsgclientpicschangessinceresponseappchange(x, 5) +} + +if o.has_force_full_app_update { +res << vproto.pack_bool_field(o.force_full_app_update, 6) +} + +if o.has_force_full_package_update { +res << vproto.pack_bool_field(o.force_full_package_update, 7) +} + +return res +} + +pub fn cmsgclientpicschangessinceresponse_unpack(buf []byte) ?CMsgClientPIcschangesSinceResponse { +mut res := CMsgClientPIcschangesSinceResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_current_change_number = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.current_change_number = v +i = ii +} + +2 { +res.has_since_change_number = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.since_change_number = v +i = ii +} + +3 { +res.has_force_full_update = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.force_full_update = v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientpicschangessinceresponsepackagechange(cur_buf, tag_wiretype.wire_type)? +res.package_changes << v +i = ii +} + +5 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientpicschangessinceresponseappchange(cur_buf, tag_wiretype.wire_type)? +res.app_changes << v +i = ii +} + +6 { +res.has_force_full_app_update = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.force_full_app_update = v +i = ii +} + +7 { +res.has_force_full_package_update = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.force_full_package_update = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientpicschangessinceresponse() CMsgClientPIcschangesSinceResponse { +return CMsgClientPIcschangesSinceResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientpicschangessinceresponse(o CMsgClientPIcschangesSinceResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientpicschangessinceresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientPIcschangesSinceResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientpicschangessinceresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientPIcsproductInfoRequestAppInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +access_token u64 +has_access_token bool +only_public bool +has_only_public bool +} +pub fn (o &CMsgClientPIcsproductInfoRequestAppInfo) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_access_token { +res << vproto.pack_uint64_field(o.access_token, 2) +} + +if o.has_only_public { +res << vproto.pack_bool_field(o.only_public, 3) +} + +return res +} + +pub fn cmsgclientpicsproductinforequestappinfo_unpack(buf []byte) ?CMsgClientPIcsproductInfoRequestAppInfo { +mut res := CMsgClientPIcsproductInfoRequestAppInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_access_token = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.access_token = v +i = ii +} + +3 { +res.has_only_public = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.only_public = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientpicsproductinforequestappinfo() CMsgClientPIcsproductInfoRequestAppInfo { +return CMsgClientPIcsproductInfoRequestAppInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientpicsproductinforequestappinfo(o CMsgClientPIcsproductInfoRequestAppInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientpicsproductinforequestappinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientPIcsproductInfoRequestAppInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientpicsproductinforequestappinfo_unpack(v)? +return i, unpacked +} +pub struct CMsgClientPIcsproductInfoRequestPackageInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +packageid u32 +has_packageid bool +access_token u64 +has_access_token bool +} +pub fn (o &CMsgClientPIcsproductInfoRequestPackageInfo) pack() []byte { +mut res := []byte{} +if o.has_packageid { +res << vproto.pack_uint32_field(o.packageid, 1) +} + +if o.has_access_token { +res << vproto.pack_uint64_field(o.access_token, 2) +} + +return res +} + +pub fn cmsgclientpicsproductinforequestpackageinfo_unpack(buf []byte) ?CMsgClientPIcsproductInfoRequestPackageInfo { +mut res := CMsgClientPIcsproductInfoRequestPackageInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_packageid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.packageid = v +i = ii +} + +2 { +res.has_access_token = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.access_token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientpicsproductinforequestpackageinfo() CMsgClientPIcsproductInfoRequestPackageInfo { +return CMsgClientPIcsproductInfoRequestPackageInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientpicsproductinforequestpackageinfo(o CMsgClientPIcsproductInfoRequestPackageInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientpicsproductinforequestpackageinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientPIcsproductInfoRequestPackageInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientpicsproductinforequestpackageinfo_unpack(v)? +return i, unpacked +} +pub struct CMsgClientPIcsproductInfoRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +packages []CMsgClientPIcsproductInfoRequestPackageInfo +apps []CMsgClientPIcsproductInfoRequestAppInfo +meta_data_only bool +has_meta_data_only bool +num_prev_failed u32 +has_num_prev_failed bool +supports_package_tokens u32 +has_supports_package_tokens bool +} +pub fn (o &CMsgClientPIcsproductInfoRequest) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.packages { +res << zzz_vproto_internal_pack_cmsgclientpicsproductinforequestpackageinfo(x, 1) +} + +// [packed=false] +for _, x in o.apps { +res << zzz_vproto_internal_pack_cmsgclientpicsproductinforequestappinfo(x, 2) +} + +if o.has_meta_data_only { +res << vproto.pack_bool_field(o.meta_data_only, 3) +} + +if o.has_num_prev_failed { +res << vproto.pack_uint32_field(o.num_prev_failed, 4) +} + +if o.has_supports_package_tokens { +res << vproto.pack_uint32_field(o.supports_package_tokens, 5) +} + +return res +} + +pub fn cmsgclientpicsproductinforequest_unpack(buf []byte) ?CMsgClientPIcsproductInfoRequest { +mut res := CMsgClientPIcsproductInfoRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientpicsproductinforequestpackageinfo(cur_buf, tag_wiretype.wire_type)? +res.packages << v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientpicsproductinforequestappinfo(cur_buf, tag_wiretype.wire_type)? +res.apps << v +i = ii +} + +3 { +res.has_meta_data_only = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.meta_data_only = v +i = ii +} + +4 { +res.has_num_prev_failed = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.num_prev_failed = v +i = ii +} + +5 { +res.has_supports_package_tokens = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.supports_package_tokens = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientpicsproductinforequest() CMsgClientPIcsproductInfoRequest { +return CMsgClientPIcsproductInfoRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientpicsproductinforequest(o CMsgClientPIcsproductInfoRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientpicsproductinforequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientPIcsproductInfoRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientpicsproductinforequest_unpack(v)? +return i, unpacked +} +pub struct CMsgClientPIcsproductInfoResponseAppInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +change_number u32 +has_change_number bool +missing_token bool +has_missing_token bool +sha []byte +has_sha bool +buffer []byte +has_buffer bool +only_public bool +has_only_public bool +size u32 +has_size bool +} +pub fn (o &CMsgClientPIcsproductInfoResponseAppInfo) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_change_number { +res << vproto.pack_uint32_field(o.change_number, 2) +} + +if o.has_missing_token { +res << vproto.pack_bool_field(o.missing_token, 3) +} + +if o.has_sha { +res << vproto.pack_bytes_field(o.sha, 4) +} + +if o.has_buffer { +res << vproto.pack_bytes_field(o.buffer, 5) +} + +if o.has_only_public { +res << vproto.pack_bool_field(o.only_public, 6) +} + +if o.has_size { +res << vproto.pack_uint32_field(o.size, 7) +} + +return res +} + +pub fn cmsgclientpicsproductinforesponseappinfo_unpack(buf []byte) ?CMsgClientPIcsproductInfoResponseAppInfo { +mut res := CMsgClientPIcsproductInfoResponseAppInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_change_number = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.change_number = v +i = ii +} + +3 { +res.has_missing_token = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.missing_token = v +i = ii +} + +4 { +res.has_sha = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha = v +i = ii +} + +5 { +res.has_buffer = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.buffer = v +i = ii +} + +6 { +res.has_only_public = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.only_public = v +i = ii +} + +7 { +res.has_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.size = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientpicsproductinforesponseappinfo() CMsgClientPIcsproductInfoResponseAppInfo { +return CMsgClientPIcsproductInfoResponseAppInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientpicsproductinforesponseappinfo(o CMsgClientPIcsproductInfoResponseAppInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientpicsproductinforesponseappinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientPIcsproductInfoResponseAppInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientpicsproductinforesponseappinfo_unpack(v)? +return i, unpacked +} +pub struct CMsgClientPIcsproductInfoResponsePackageInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +packageid u32 +has_packageid bool +change_number u32 +has_change_number bool +missing_token bool +has_missing_token bool +sha []byte +has_sha bool +buffer []byte +has_buffer bool +size u32 +has_size bool +} +pub fn (o &CMsgClientPIcsproductInfoResponsePackageInfo) pack() []byte { +mut res := []byte{} +if o.has_packageid { +res << vproto.pack_uint32_field(o.packageid, 1) +} + +if o.has_change_number { +res << vproto.pack_uint32_field(o.change_number, 2) +} + +if o.has_missing_token { +res << vproto.pack_bool_field(o.missing_token, 3) +} + +if o.has_sha { +res << vproto.pack_bytes_field(o.sha, 4) +} + +if o.has_buffer { +res << vproto.pack_bytes_field(o.buffer, 5) +} + +if o.has_size { +res << vproto.pack_uint32_field(o.size, 6) +} + +return res +} + +pub fn cmsgclientpicsproductinforesponsepackageinfo_unpack(buf []byte) ?CMsgClientPIcsproductInfoResponsePackageInfo { +mut res := CMsgClientPIcsproductInfoResponsePackageInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_packageid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.packageid = v +i = ii +} + +2 { +res.has_change_number = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.change_number = v +i = ii +} + +3 { +res.has_missing_token = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.missing_token = v +i = ii +} + +4 { +res.has_sha = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha = v +i = ii +} + +5 { +res.has_buffer = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.buffer = v +i = ii +} + +6 { +res.has_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.size = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientpicsproductinforesponsepackageinfo() CMsgClientPIcsproductInfoResponsePackageInfo { +return CMsgClientPIcsproductInfoResponsePackageInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientpicsproductinforesponsepackageinfo(o CMsgClientPIcsproductInfoResponsePackageInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientpicsproductinforesponsepackageinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientPIcsproductInfoResponsePackageInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientpicsproductinforesponsepackageinfo_unpack(v)? +return i, unpacked +} +pub struct CMsgClientPIcsproductInfoResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +apps []CMsgClientPIcsproductInfoResponseAppInfo +unknown_appids []u32 +packages []CMsgClientPIcsproductInfoResponsePackageInfo +unknown_packageids []u32 +meta_data_only bool +has_meta_data_only bool +response_pending bool +has_response_pending bool +http_min_size u32 +has_http_min_size bool +http_host string +has_http_host bool +} +pub fn (o &CMsgClientPIcsproductInfoResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.apps { +res << zzz_vproto_internal_pack_cmsgclientpicsproductinforesponseappinfo(x, 1) +} + +// [packed=false] +for _, x in o.unknown_appids { +res << vproto.pack_uint32_field(x, 2) +} + +// [packed=false] +for _, x in o.packages { +res << zzz_vproto_internal_pack_cmsgclientpicsproductinforesponsepackageinfo(x, 3) +} + +// [packed=false] +for _, x in o.unknown_packageids { +res << vproto.pack_uint32_field(x, 4) +} + +if o.has_meta_data_only { +res << vproto.pack_bool_field(o.meta_data_only, 5) +} + +if o.has_response_pending { +res << vproto.pack_bool_field(o.response_pending, 6) +} + +if o.has_http_min_size { +res << vproto.pack_uint32_field(o.http_min_size, 7) +} + +if o.has_http_host { +res << vproto.pack_string_field(o.http_host, 8) +} + +return res +} + +pub fn cmsgclientpicsproductinforesponse_unpack(buf []byte) ?CMsgClientPIcsproductInfoResponse { +mut res := CMsgClientPIcsproductInfoResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientpicsproductinforesponseappinfo(cur_buf, tag_wiretype.wire_type)? +res.apps << v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.unknown_appids << v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientpicsproductinforesponsepackageinfo(cur_buf, tag_wiretype.wire_type)? +res.packages << v +i = ii +} + +4 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.unknown_packageids << v +i = ii +} + +5 { +res.has_meta_data_only = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.meta_data_only = v +i = ii +} + +6 { +res.has_response_pending = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.response_pending = v +i = ii +} + +7 { +res.has_http_min_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.http_min_size = v +i = ii +} + +8 { +res.has_http_host = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.http_host = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientpicsproductinforesponse() CMsgClientPIcsproductInfoResponse { +return CMsgClientPIcsproductInfoResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientpicsproductinforesponse(o CMsgClientPIcsproductInfoResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientpicsproductinforesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientPIcsproductInfoResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientpicsproductinforesponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientPIcsaccessTokenRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +packageids []u32 +appids []u32 +} +pub fn (o &CMsgClientPIcsaccessTokenRequest) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.packageids { +res << vproto.pack_uint32_field(x, 1) +} + +// [packed=false] +for _, x in o.appids { +res << vproto.pack_uint32_field(x, 2) +} + +return res +} + +pub fn cmsgclientpicsaccesstokenrequest_unpack(buf []byte) ?CMsgClientPIcsaccessTokenRequest { +mut res := CMsgClientPIcsaccessTokenRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.packageids << v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientpicsaccesstokenrequest() CMsgClientPIcsaccessTokenRequest { +return CMsgClientPIcsaccessTokenRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientpicsaccesstokenrequest(o CMsgClientPIcsaccessTokenRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientpicsaccesstokenrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientPIcsaccessTokenRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientpicsaccesstokenrequest_unpack(v)? +return i, unpacked +} +pub struct CMsgClientPIcsaccessTokenResponsePackageToken { +mut: +unknown_fields []vproto.UnknownField +pub mut: +packageid u32 +has_packageid bool +access_token u64 +has_access_token bool +} +pub fn (o &CMsgClientPIcsaccessTokenResponsePackageToken) pack() []byte { +mut res := []byte{} +if o.has_packageid { +res << vproto.pack_uint32_field(o.packageid, 1) +} + +if o.has_access_token { +res << vproto.pack_uint64_field(o.access_token, 2) +} + +return res +} + +pub fn cmsgclientpicsaccesstokenresponsepackagetoken_unpack(buf []byte) ?CMsgClientPIcsaccessTokenResponsePackageToken { +mut res := CMsgClientPIcsaccessTokenResponsePackageToken{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_packageid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.packageid = v +i = ii +} + +2 { +res.has_access_token = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.access_token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientpicsaccesstokenresponsepackagetoken() CMsgClientPIcsaccessTokenResponsePackageToken { +return CMsgClientPIcsaccessTokenResponsePackageToken{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientpicsaccesstokenresponsepackagetoken(o CMsgClientPIcsaccessTokenResponsePackageToken, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientpicsaccesstokenresponsepackagetoken(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientPIcsaccessTokenResponsePackageToken) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientpicsaccesstokenresponsepackagetoken_unpack(v)? +return i, unpacked +} +pub struct CMsgClientPIcsaccessTokenResponseAppToken { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +access_token u64 +has_access_token bool +} +pub fn (o &CMsgClientPIcsaccessTokenResponseAppToken) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_access_token { +res << vproto.pack_uint64_field(o.access_token, 2) +} + +return res +} + +pub fn cmsgclientpicsaccesstokenresponseapptoken_unpack(buf []byte) ?CMsgClientPIcsaccessTokenResponseAppToken { +mut res := CMsgClientPIcsaccessTokenResponseAppToken{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_access_token = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.access_token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientpicsaccesstokenresponseapptoken() CMsgClientPIcsaccessTokenResponseAppToken { +return CMsgClientPIcsaccessTokenResponseAppToken{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientpicsaccesstokenresponseapptoken(o CMsgClientPIcsaccessTokenResponseAppToken, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientpicsaccesstokenresponseapptoken(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientPIcsaccessTokenResponseAppToken) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientpicsaccesstokenresponseapptoken_unpack(v)? +return i, unpacked +} +pub struct CMsgClientPIcsaccessTokenResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +package_access_tokens []CMsgClientPIcsaccessTokenResponsePackageToken +package_denied_tokens []u32 +app_access_tokens []CMsgClientPIcsaccessTokenResponseAppToken +app_denied_tokens []u32 +} +pub fn (o &CMsgClientPIcsaccessTokenResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.package_access_tokens { +res << zzz_vproto_internal_pack_cmsgclientpicsaccesstokenresponsepackagetoken(x, 1) +} + +// [packed=false] +for _, x in o.package_denied_tokens { +res << vproto.pack_uint32_field(x, 2) +} + +// [packed=false] +for _, x in o.app_access_tokens { +res << zzz_vproto_internal_pack_cmsgclientpicsaccesstokenresponseapptoken(x, 3) +} + +// [packed=false] +for _, x in o.app_denied_tokens { +res << vproto.pack_uint32_field(x, 4) +} + +return res +} + +pub fn cmsgclientpicsaccesstokenresponse_unpack(buf []byte) ?CMsgClientPIcsaccessTokenResponse { +mut res := CMsgClientPIcsaccessTokenResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientpicsaccesstokenresponsepackagetoken(cur_buf, tag_wiretype.wire_type)? +res.package_access_tokens << v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.package_denied_tokens << v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientpicsaccesstokenresponseapptoken(cur_buf, tag_wiretype.wire_type)? +res.app_access_tokens << v +i = ii +} + +4 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_denied_tokens << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientpicsaccesstokenresponse() CMsgClientPIcsaccessTokenResponse { +return CMsgClientPIcsaccessTokenResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientpicsaccesstokenresponse(o CMsgClientPIcsaccessTokenResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientpicsaccesstokenresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientPIcsaccessTokenResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientpicsaccesstokenresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUFsgetUGcdetails { +mut: +unknown_fields []vproto.UnknownField +pub mut: +hcontent u64 +has_hcontent bool +} +pub fn (o &CMsgClientUFsgetUGcdetails) pack() []byte { +mut res := []byte{} +if o.has_hcontent { +res << vproto.pack_64bit_field(o.hcontent, 1) +} + +return res +} + +pub fn cmsgclientufsgetugcdetails_unpack(buf []byte) ?CMsgClientUFsgetUGcdetails { +mut res := CMsgClientUFsgetUGcdetails{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_hcontent = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.hcontent = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientufsgetugcdetails() CMsgClientUFsgetUGcdetails { +return CMsgClientUFsgetUGcdetails{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientufsgetugcdetails(o CMsgClientUFsgetUGcdetails, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientufsgetugcdetails(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUFsgetUGcdetails) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientufsgetugcdetails_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUFsgetUGcdetailsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +url string +has_url bool +app_id u32 +has_app_id bool +filename string +has_filename bool +steamid_creator u64 +has_steamid_creator bool +file_size u32 +has_file_size bool +compressed_file_size u32 +has_compressed_file_size bool +rangecheck_host string +has_rangecheck_host bool +file_encoded_sha1 string +has_file_encoded_sha1 bool +} +pub fn (o &CMsgClientUFsgetUGcdetailsResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_url { +res << vproto.pack_string_field(o.url, 2) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 3) +} + +if o.has_filename { +res << vproto.pack_string_field(o.filename, 4) +} + +if o.has_steamid_creator { +res << vproto.pack_64bit_field(o.steamid_creator, 5) +} + +if o.has_file_size { +res << vproto.pack_uint32_field(o.file_size, 6) +} + +if o.has_compressed_file_size { +res << vproto.pack_uint32_field(o.compressed_file_size, 7) +} + +if o.has_rangecheck_host { +res << vproto.pack_string_field(o.rangecheck_host, 8) +} + +if o.has_file_encoded_sha1 { +res << vproto.pack_string_field(o.file_encoded_sha1, 9) +} + +return res +} + +pub fn cmsgclientufsgetugcdetailsresponse_unpack(buf []byte) ?CMsgClientUFsgetUGcdetailsResponse { +mut res := CMsgClientUFsgetUGcdetailsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url = v +i = ii +} + +3 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +4 { +res.has_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.filename = v +i = ii +} + +5 { +res.has_steamid_creator = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_creator = v +i = ii +} + +6 { +res.has_file_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.file_size = v +i = ii +} + +7 { +res.has_compressed_file_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.compressed_file_size = v +i = ii +} + +8 { +res.has_rangecheck_host = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.rangecheck_host = v +i = ii +} + +9 { +res.has_file_encoded_sha1 = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.file_encoded_sha1 = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientufsgetugcdetailsresponse() CMsgClientUFsgetUGcdetailsResponse { +return CMsgClientUFsgetUGcdetailsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientufsgetugcdetailsresponse(o CMsgClientUFsgetUGcdetailsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientufsgetugcdetailsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUFsgetUGcdetailsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientufsgetugcdetailsresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUFsgetSingleFileInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +file_name string +has_file_name bool +} +pub fn (o &CMsgClientUFsgetSingleFileInfo) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_file_name { +res << vproto.pack_string_field(o.file_name, 2) +} + +return res +} + +pub fn cmsgclientufsgetsinglefileinfo_unpack(buf []byte) ?CMsgClientUFsgetSingleFileInfo { +mut res := CMsgClientUFsgetSingleFileInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_file_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.file_name = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientufsgetsinglefileinfo() CMsgClientUFsgetSingleFileInfo { +return CMsgClientUFsgetSingleFileInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientufsgetsinglefileinfo(o CMsgClientUFsgetSingleFileInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientufsgetsinglefileinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUFsgetSingleFileInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientufsgetsinglefileinfo_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUFsgetSingleFileInfoResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +app_id u32 +has_app_id bool +file_name string +has_file_name bool +sha_file []byte +has_sha_file bool +time_stamp u64 +has_time_stamp bool +raw_file_size u32 +has_raw_file_size bool +is_explicit_delete bool +has_is_explicit_delete bool +} +pub fn (o &CMsgClientUFsgetSingleFileInfoResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 2) +} + +if o.has_file_name { +res << vproto.pack_string_field(o.file_name, 3) +} + +if o.has_sha_file { +res << vproto.pack_bytes_field(o.sha_file, 4) +} + +if o.has_time_stamp { +res << vproto.pack_uint64_field(o.time_stamp, 5) +} + +if o.has_raw_file_size { +res << vproto.pack_uint32_field(o.raw_file_size, 6) +} + +if o.has_is_explicit_delete { +res << vproto.pack_bool_field(o.is_explicit_delete, 7) +} + +return res +} + +pub fn cmsgclientufsgetsinglefileinforesponse_unpack(buf []byte) ?CMsgClientUFsgetSingleFileInfoResponse { +mut res := CMsgClientUFsgetSingleFileInfoResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +3 { +res.has_file_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.file_name = v +i = ii +} + +4 { +res.has_sha_file = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha_file = v +i = ii +} + +5 { +res.has_time_stamp = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.time_stamp = v +i = ii +} + +6 { +res.has_raw_file_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.raw_file_size = v +i = ii +} + +7 { +res.has_is_explicit_delete = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_explicit_delete = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientufsgetsinglefileinforesponse() CMsgClientUFsgetSingleFileInfoResponse { +return CMsgClientUFsgetSingleFileInfoResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientufsgetsinglefileinforesponse(o CMsgClientUFsgetSingleFileInfoResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientufsgetsinglefileinforesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUFsgetSingleFileInfoResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientufsgetsinglefileinforesponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUFsshareFile { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +file_name string +has_file_name bool +} +pub fn (o &CMsgClientUFsshareFile) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_file_name { +res << vproto.pack_string_field(o.file_name, 2) +} + +return res +} + +pub fn cmsgclientufssharefile_unpack(buf []byte) ?CMsgClientUFsshareFile { +mut res := CMsgClientUFsshareFile{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_file_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.file_name = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientufssharefile() CMsgClientUFsshareFile { +return CMsgClientUFsshareFile{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientufssharefile(o CMsgClientUFsshareFile, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientufssharefile(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUFsshareFile) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientufssharefile_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUFsshareFileResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +hcontent u64 +has_hcontent bool +} +pub fn (o &CMsgClientUFsshareFileResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_hcontent { +res << vproto.pack_64bit_field(o.hcontent, 2) +} + +return res +} + +pub fn cmsgclientufssharefileresponse_unpack(buf []byte) ?CMsgClientUFsshareFileResponse { +mut res := CMsgClientUFsshareFileResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_hcontent = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.hcontent = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientufssharefileresponse() CMsgClientUFsshareFileResponse { +return CMsgClientUFsshareFileResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientufssharefileresponse(o CMsgClientUFsshareFileResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientufssharefileresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUFsshareFileResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientufssharefileresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientAMgetClanOfficers { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid_clan u64 +has_steamid_clan bool +} +pub fn (o &CMsgClientAMgetClanOfficers) pack() []byte { +mut res := []byte{} +if o.has_steamid_clan { +res << vproto.pack_64bit_field(o.steamid_clan, 1) +} + +return res +} + +pub fn cmsgclientamgetclanofficers_unpack(buf []byte) ?CMsgClientAMgetClanOfficers { +mut res := CMsgClientAMgetClanOfficers{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid_clan = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_clan = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientamgetclanofficers() CMsgClientAMgetClanOfficers { +return CMsgClientAMgetClanOfficers{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientamgetclanofficers(o CMsgClientAMgetClanOfficers, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientamgetclanofficers(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientAMgetClanOfficers) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientamgetclanofficers_unpack(v)? +return i, unpacked +} +pub struct CMsgClientAMgetClanOfficersResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +steamid_clan u64 +has_steamid_clan bool +officer_count int +has_officer_count bool +} +pub fn (o &CMsgClientAMgetClanOfficersResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_steamid_clan { +res << vproto.pack_64bit_field(o.steamid_clan, 2) +} + +if o.has_officer_count { +res << vproto.pack_int32_field(o.officer_count, 3) +} + +return res +} + +pub fn cmsgclientamgetclanofficersresponse_unpack(buf []byte) ?CMsgClientAMgetClanOfficersResponse { +mut res := CMsgClientAMgetClanOfficersResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_steamid_clan = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_clan = v +i = ii +} + +3 { +res.has_officer_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.officer_count = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientamgetclanofficersresponse() CMsgClientAMgetClanOfficersResponse { +return CMsgClientAMgetClanOfficersResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientamgetclanofficersresponse(o CMsgClientAMgetClanOfficersResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientamgetclanofficersresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientAMgetClanOfficersResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientamgetclanofficersresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientAMgetPersonaNameHistoryIdInstance { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +} +pub fn (o &CMsgClientAMgetPersonaNameHistoryIdInstance) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +return res +} + +pub fn cmsgclientamgetpersonanamehistoryidinstance_unpack(buf []byte) ?CMsgClientAMgetPersonaNameHistoryIdInstance { +mut res := CMsgClientAMgetPersonaNameHistoryIdInstance{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientamgetpersonanamehistoryidinstance() CMsgClientAMgetPersonaNameHistoryIdInstance { +return CMsgClientAMgetPersonaNameHistoryIdInstance{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientamgetpersonanamehistoryidinstance(o CMsgClientAMgetPersonaNameHistoryIdInstance, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientamgetpersonanamehistoryidinstance(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientAMgetPersonaNameHistoryIdInstance) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientamgetpersonanamehistoryidinstance_unpack(v)? +return i, unpacked +} +pub struct CMsgClientAMgetPersonaNameHistory { +mut: +unknown_fields []vproto.UnknownField +pub mut: +id_count int +has_id_count bool +ids []CMsgClientAMgetPersonaNameHistoryIdInstance +} +pub fn (o &CMsgClientAMgetPersonaNameHistory) pack() []byte { +mut res := []byte{} +if o.has_id_count { +res << vproto.pack_int32_field(o.id_count, 1) +} + +// [packed=false] +for _, x in o.ids { +res << zzz_vproto_internal_pack_cmsgclientamgetpersonanamehistoryidinstance(x, 2) +} + +return res +} + +pub fn cmsgclientamgetpersonanamehistory_unpack(buf []byte) ?CMsgClientAMgetPersonaNameHistory { +mut res := CMsgClientAMgetPersonaNameHistory{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_id_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.id_count = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientamgetpersonanamehistoryidinstance(cur_buf, tag_wiretype.wire_type)? +res.ids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientamgetpersonanamehistory() CMsgClientAMgetPersonaNameHistory { +return CMsgClientAMgetPersonaNameHistory{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientamgetpersonanamehistory(o CMsgClientAMgetPersonaNameHistory, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientamgetpersonanamehistory(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientAMgetPersonaNameHistory) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientamgetpersonanamehistory_unpack(v)? +return i, unpacked +} +pub struct CMsgClientAMgetPersonaNameHistoryResponseNameTableInstanceNameInstance { +mut: +unknown_fields []vproto.UnknownField +pub mut: +name_since u32 +has_name_since bool +name string +has_name bool +} +pub fn (o &CMsgClientAMgetPersonaNameHistoryResponseNameTableInstanceNameInstance) pack() []byte { +mut res := []byte{} +if o.has_name_since { +res << vproto.pack_32bit_field(o.name_since, 1) +} + +if o.has_name { +res << vproto.pack_string_field(o.name, 2) +} + +return res +} + +pub fn cmsgclientamgetpersonanamehistoryresponsenametableinstancenameinstance_unpack(buf []byte) ?CMsgClientAMgetPersonaNameHistoryResponseNameTableInstanceNameInstance { +mut res := CMsgClientAMgetPersonaNameHistoryResponseNameTableInstanceNameInstance{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_name_since = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.name_since = v +i = ii +} + +2 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientamgetpersonanamehistoryresponsenametableinstancenameinstance() CMsgClientAMgetPersonaNameHistoryResponseNameTableInstanceNameInstance { +return CMsgClientAMgetPersonaNameHistoryResponseNameTableInstanceNameInstance{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientamgetpersonanamehistoryresponsenametableinstancenameinstance(o CMsgClientAMgetPersonaNameHistoryResponseNameTableInstanceNameInstance, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientamgetpersonanamehistoryresponsenametableinstancenameinstance(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientAMgetPersonaNameHistoryResponseNameTableInstanceNameInstance) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientamgetpersonanamehistoryresponsenametableinstancenameinstance_unpack(v)? +return i, unpacked +} +pub struct CMsgClientAMgetPersonaNameHistoryResponseNameTableInstance { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +steamid u64 +has_steamid bool +names []CMsgClientAMgetPersonaNameHistoryResponseNameTableInstanceNameInstance +} +pub fn (o &CMsgClientAMgetPersonaNameHistoryResponseNameTableInstance) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 2) +} + +// [packed=false] +for _, x in o.names { +res << zzz_vproto_internal_pack_cmsgclientamgetpersonanamehistoryresponsenametableinstancenameinstance(x, 3) +} + +return res +} + +pub fn cmsgclientamgetpersonanamehistoryresponsenametableinstance_unpack(buf []byte) ?CMsgClientAMgetPersonaNameHistoryResponseNameTableInstance { +mut res := CMsgClientAMgetPersonaNameHistoryResponseNameTableInstance{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientamgetpersonanamehistoryresponsenametableinstancenameinstance(cur_buf, tag_wiretype.wire_type)? +res.names << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientamgetpersonanamehistoryresponsenametableinstance() CMsgClientAMgetPersonaNameHistoryResponseNameTableInstance { +return CMsgClientAMgetPersonaNameHistoryResponseNameTableInstance{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientamgetpersonanamehistoryresponsenametableinstance(o CMsgClientAMgetPersonaNameHistoryResponseNameTableInstance, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientamgetpersonanamehistoryresponsenametableinstance(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientAMgetPersonaNameHistoryResponseNameTableInstance) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientamgetpersonanamehistoryresponsenametableinstance_unpack(v)? +return i, unpacked +} +pub struct CMsgClientAMgetPersonaNameHistoryResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +responses []CMsgClientAMgetPersonaNameHistoryResponseNameTableInstance +} +pub fn (o &CMsgClientAMgetPersonaNameHistoryResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.responses { +res << zzz_vproto_internal_pack_cmsgclientamgetpersonanamehistoryresponsenametableinstance(x, 2) +} + +return res +} + +pub fn cmsgclientamgetpersonanamehistoryresponse_unpack(buf []byte) ?CMsgClientAMgetPersonaNameHistoryResponse { +mut res := CMsgClientAMgetPersonaNameHistoryResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientamgetpersonanamehistoryresponsenametableinstance(cur_buf, tag_wiretype.wire_type)? +res.responses << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientamgetpersonanamehistoryresponse() CMsgClientAMgetPersonaNameHistoryResponse { +return CMsgClientAMgetPersonaNameHistoryResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientamgetpersonanamehistoryresponse(o CMsgClientAMgetPersonaNameHistoryResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientamgetpersonanamehistoryresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientAMgetPersonaNameHistoryResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientamgetpersonanamehistoryresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientDeregisterWithServer { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eservertype u32 +has_eservertype bool +app_id u32 +has_app_id bool +} +pub fn (o &CMsgClientDeregisterWithServer) pack() []byte { +mut res := []byte{} +if o.has_eservertype { +res << vproto.pack_uint32_field(o.eservertype, 1) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 2) +} + +return res +} + +pub fn cmsgclientderegisterwithserver_unpack(buf []byte) ?CMsgClientDeregisterWithServer { +mut res := CMsgClientDeregisterWithServer{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eservertype = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eservertype = v +i = ii +} + +2 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientderegisterwithserver() CMsgClientDeregisterWithServer { +return CMsgClientDeregisterWithServer{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientderegisterwithserver(o CMsgClientDeregisterWithServer, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientderegisterwithserver(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientDeregisterWithServer) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientderegisterwithserver_unpack(v)? +return i, unpacked +} +pub struct CMsgClientClanStateNameInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +clan_name string +has_clan_name bool +sha_avatar []byte +has_sha_avatar bool +} +pub fn (o &CMsgClientClanStateNameInfo) pack() []byte { +mut res := []byte{} +if o.has_clan_name { +res << vproto.pack_string_field(o.clan_name, 1) +} + +if o.has_sha_avatar { +res << vproto.pack_bytes_field(o.sha_avatar, 2) +} + +return res +} + +pub fn cmsgclientclanstatenameinfo_unpack(buf []byte) ?CMsgClientClanStateNameInfo { +mut res := CMsgClientClanStateNameInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_clan_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.clan_name = v +i = ii +} + +2 { +res.has_sha_avatar = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha_avatar = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientclanstatenameinfo() CMsgClientClanStateNameInfo { +return CMsgClientClanStateNameInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientclanstatenameinfo(o CMsgClientClanStateNameInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientclanstatenameinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientClanStateNameInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientclanstatenameinfo_unpack(v)? +return i, unpacked +} +pub struct CMsgClientClanStateUserCounts { +mut: +unknown_fields []vproto.UnknownField +pub mut: +members u32 +has_members bool +online u32 +has_online bool +chatting u32 +has_chatting bool +in_game u32 +has_in_game bool +chat_room_members u32 +has_chat_room_members bool +} +pub fn (o &CMsgClientClanStateUserCounts) pack() []byte { +mut res := []byte{} +if o.has_members { +res << vproto.pack_uint32_field(o.members, 1) +} + +if o.has_online { +res << vproto.pack_uint32_field(o.online, 2) +} + +if o.has_chatting { +res << vproto.pack_uint32_field(o.chatting, 3) +} + +if o.has_in_game { +res << vproto.pack_uint32_field(o.in_game, 4) +} + +if o.has_chat_room_members { +res << vproto.pack_uint32_field(o.chat_room_members, 5) +} + +return res +} + +pub fn cmsgclientclanstateusercounts_unpack(buf []byte) ?CMsgClientClanStateUserCounts { +mut res := CMsgClientClanStateUserCounts{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_members = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.members = v +i = ii +} + +2 { +res.has_online = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.online = v +i = ii +} + +3 { +res.has_chatting = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.chatting = v +i = ii +} + +4 { +res.has_in_game = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.in_game = v +i = ii +} + +5 { +res.has_chat_room_members = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.chat_room_members = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientclanstateusercounts() CMsgClientClanStateUserCounts { +return CMsgClientClanStateUserCounts{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientclanstateusercounts(o CMsgClientClanStateUserCounts, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientclanstateusercounts(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientClanStateUserCounts) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientclanstateusercounts_unpack(v)? +return i, unpacked +} +pub struct CMsgClientClanStateEvent { +mut: +unknown_fields []vproto.UnknownField +pub mut: +gid u64 +has_gid bool +event_time u32 +has_event_time bool +headline string +has_headline bool +game_id u64 +has_game_id bool +just_posted bool +has_just_posted bool +} +pub fn (o &CMsgClientClanStateEvent) pack() []byte { +mut res := []byte{} +if o.has_gid { +res << vproto.pack_64bit_field(o.gid, 1) +} + +if o.has_event_time { +res << vproto.pack_uint32_field(o.event_time, 2) +} + +if o.has_headline { +res << vproto.pack_string_field(o.headline, 3) +} + +if o.has_game_id { +res << vproto.pack_64bit_field(o.game_id, 4) +} + +if o.has_just_posted { +res << vproto.pack_bool_field(o.just_posted, 5) +} + +return res +} + +pub fn cmsgclientclanstateevent_unpack(buf []byte) ?CMsgClientClanStateEvent { +mut res := CMsgClientClanStateEvent{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_gid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.gid = v +i = ii +} + +2 { +res.has_event_time = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.event_time = v +i = ii +} + +3 { +res.has_headline = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.headline = v +i = ii +} + +4 { +res.has_game_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.game_id = v +i = ii +} + +5 { +res.has_just_posted = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.just_posted = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientclanstateevent() CMsgClientClanStateEvent { +return CMsgClientClanStateEvent{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientclanstateevent(o CMsgClientClanStateEvent, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientclanstateevent(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientClanStateEvent) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientclanstateevent_unpack(v)? +return i, unpacked +} +pub struct CMsgClientClanState { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid_clan u64 +has_steamid_clan bool +clan_account_flags u32 +has_clan_account_flags bool +name_info CMsgClientClanStateNameInfo +has_name_info bool +user_counts CMsgClientClanStateUserCounts +has_user_counts bool +events []CMsgClientClanStateEvent +announcements []CMsgClientClanStateEvent +chat_room_private bool +has_chat_room_private bool +} +pub fn (o &CMsgClientClanState) pack() []byte { +mut res := []byte{} +if o.has_steamid_clan { +res << vproto.pack_64bit_field(o.steamid_clan, 1) +} + +if o.has_clan_account_flags { +res << vproto.pack_uint32_field(o.clan_account_flags, 3) +} + +if o.has_name_info { +res << zzz_vproto_internal_pack_cmsgclientclanstatenameinfo(o.name_info, 4) +} + +if o.has_user_counts { +res << zzz_vproto_internal_pack_cmsgclientclanstateusercounts(o.user_counts, 5) +} + +// [packed=false] +for _, x in o.events { +res << zzz_vproto_internal_pack_cmsgclientclanstateevent(x, 6) +} + +// [packed=false] +for _, x in o.announcements { +res << zzz_vproto_internal_pack_cmsgclientclanstateevent(x, 7) +} + +if o.has_chat_room_private { +res << vproto.pack_bool_field(o.chat_room_private, 8) +} + +return res +} + +pub fn cmsgclientclanstate_unpack(buf []byte) ?CMsgClientClanState { +mut res := CMsgClientClanState{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid_clan = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_clan = v +i = ii +} + +3 { +res.has_clan_account_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.clan_account_flags = v +i = ii +} + +4 { +res.has_name_info = true +ii, v := zzz_vproto_internal_unpack_cmsgclientclanstatenameinfo(cur_buf, tag_wiretype.wire_type)? +res.name_info = v +i = ii +} + +5 { +res.has_user_counts = true +ii, v := zzz_vproto_internal_unpack_cmsgclientclanstateusercounts(cur_buf, tag_wiretype.wire_type)? +res.user_counts = v +i = ii +} + +6 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientclanstateevent(cur_buf, tag_wiretype.wire_type)? +res.events << v +i = ii +} + +7 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgclientclanstateevent(cur_buf, tag_wiretype.wire_type)? +res.announcements << v +i = ii +} + +8 { +res.has_chat_room_private = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.chat_room_private = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientclanstate() CMsgClientClanState { +return CMsgClientClanState{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientclanstate(o CMsgClientClanState, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientclanstate(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientClanState) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientclanstate_unpack(v)? +return i, unpacked +} +pub struct CMsgClientUnsignedInstallScript { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +file_name string +has_file_name bool +file_size u32 +has_file_size bool +signature_broken bool +has_signature_broken bool +depot_id u32 +has_depot_id bool +manifest_id u64 +has_manifest_id bool +file_flags u32 +has_file_flags bool +} +pub fn (o &CMsgClientUnsignedInstallScript) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_file_name { +res << vproto.pack_string_field(o.file_name, 2) +} + +if o.has_file_size { +res << vproto.pack_uint32_field(o.file_size, 3) +} + +if o.has_signature_broken { +res << vproto.pack_bool_field(o.signature_broken, 4) +} + +if o.has_depot_id { +res << vproto.pack_uint32_field(o.depot_id, 5) +} + +if o.has_manifest_id { +res << vproto.pack_uint64_field(o.manifest_id, 6) +} + +if o.has_file_flags { +res << vproto.pack_uint32_field(o.file_flags, 7) +} + +return res +} + +pub fn cmsgclientunsignedinstallscript_unpack(buf []byte) ?CMsgClientUnsignedInstallScript { +mut res := CMsgClientUnsignedInstallScript{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_file_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.file_name = v +i = ii +} + +3 { +res.has_file_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.file_size = v +i = ii +} + +4 { +res.has_signature_broken = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.signature_broken = v +i = ii +} + +5 { +res.has_depot_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.depot_id = v +i = ii +} + +6 { +res.has_manifest_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.manifest_id = v +i = ii +} + +7 { +res.has_file_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.file_flags = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientunsignedinstallscript() CMsgClientUnsignedInstallScript { +return CMsgClientUnsignedInstallScript{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientunsignedinstallscript(o CMsgClientUnsignedInstallScript, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientunsignedinstallscript(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientUnsignedInstallScript) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientunsignedinstallscript_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_cloud.steamclient_pb.v b/proto/steammessages_cloud.steamclient_pb.v new file mode 100644 index 0000000..3b780e2 --- /dev/null +++ b/proto/steammessages_cloud.steamclient_pb.v @@ -0,0 +1,2971 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CCloudGetUploadServerInfoRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +} +pub fn (o &CCloudGetUploadServerInfoRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +return res +} + +pub fn ccloudgetuploadserverinforequest_unpack(buf []byte) ?CCloudGetUploadServerInfoRequest { +mut res := CCloudGetUploadServerInfoRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudgetuploadserverinforequest() CCloudGetUploadServerInfoRequest { +return CCloudGetUploadServerInfoRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudgetuploadserverinforequest(o CCloudGetUploadServerInfoRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudgetuploadserverinforequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudGetUploadServerInfoRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudgetuploadserverinforequest_unpack(v)? +return i, unpacked +} +pub struct CCloudGetUploadServerInfoResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +server_url string +has_server_url bool +} +pub fn (o &CCloudGetUploadServerInfoResponse) pack() []byte { +mut res := []byte{} +if o.has_server_url { +res << vproto.pack_string_field(o.server_url, 1) +} + +return res +} + +pub fn ccloudgetuploadserverinforesponse_unpack(buf []byte) ?CCloudGetUploadServerInfoResponse { +mut res := CCloudGetUploadServerInfoResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_server_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.server_url = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudgetuploadserverinforesponse() CCloudGetUploadServerInfoResponse { +return CCloudGetUploadServerInfoResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudgetuploadserverinforesponse(o CCloudGetUploadServerInfoResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudgetuploadserverinforesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudGetUploadServerInfoResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudgetuploadserverinforesponse_unpack(v)? +return i, unpacked +} +pub struct CCloudBeginHTtpuploadRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +file_size u32 +has_file_size bool +filename string +has_filename bool +file_sha string +has_file_sha bool +is_public bool +has_is_public bool +platforms_to_sync []string +request_headers_names []string +request_headers_values []string +} +pub fn (o &CCloudBeginHTtpuploadRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_file_size { +res << vproto.pack_uint32_field(o.file_size, 2) +} + +if o.has_filename { +res << vproto.pack_string_field(o.filename, 3) +} + +if o.has_file_sha { +res << vproto.pack_string_field(o.file_sha, 4) +} + +if o.has_is_public { +res << vproto.pack_bool_field(o.is_public, 5) +} + +// [packed=false] +for _, x in o.platforms_to_sync { +res << vproto.pack_string_field(x, 6) +} + +// [packed=false] +for _, x in o.request_headers_names { +res << vproto.pack_string_field(x, 7) +} + +// [packed=false] +for _, x in o.request_headers_values { +res << vproto.pack_string_field(x, 8) +} + +return res +} + +pub fn ccloudbeginhttpuploadrequest_unpack(buf []byte) ?CCloudBeginHTtpuploadRequest { +mut res := CCloudBeginHTtpuploadRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_file_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.file_size = v +i = ii +} + +3 { +res.has_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.filename = v +i = ii +} + +4 { +res.has_file_sha = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.file_sha = v +i = ii +} + +5 { +res.has_is_public = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_public = v +i = ii +} + +6 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.platforms_to_sync << v +i = ii +} + +7 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.request_headers_names << v +i = ii +} + +8 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.request_headers_values << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudbeginhttpuploadrequest() CCloudBeginHTtpuploadRequest { +return CCloudBeginHTtpuploadRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudbeginhttpuploadrequest(o CCloudBeginHTtpuploadRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudbeginhttpuploadrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudBeginHTtpuploadRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudbeginhttpuploadrequest_unpack(v)? +return i, unpacked +} +pub struct CCloudBeginHTtpuploadResponseHTtpheaders { +mut: +unknown_fields []vproto.UnknownField +pub mut: +name string +has_name bool +value string +has_value bool +} +pub fn (o &CCloudBeginHTtpuploadResponseHTtpheaders) pack() []byte { +mut res := []byte{} +if o.has_name { +res << vproto.pack_string_field(o.name, 1) +} + +if o.has_value { +res << vproto.pack_string_field(o.value, 2) +} + +return res +} + +pub fn ccloudbeginhttpuploadresponsehttpheaders_unpack(buf []byte) ?CCloudBeginHTtpuploadResponseHTtpheaders { +mut res := CCloudBeginHTtpuploadResponseHTtpheaders{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +2 { +res.has_value = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.value = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudbeginhttpuploadresponsehttpheaders() CCloudBeginHTtpuploadResponseHTtpheaders { +return CCloudBeginHTtpuploadResponseHTtpheaders{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudbeginhttpuploadresponsehttpheaders(o CCloudBeginHTtpuploadResponseHTtpheaders, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudbeginhttpuploadresponsehttpheaders(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudBeginHTtpuploadResponseHTtpheaders) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudbeginhttpuploadresponsehttpheaders_unpack(v)? +return i, unpacked +} +pub struct CCloudBeginHTtpuploadResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +ugcid u64 +has_ugcid bool +timestamp u32 +has_timestamp bool +url_host string +has_url_host bool +url_path string +has_url_path bool +use_https bool +has_use_https bool +request_headers []CCloudBeginHTtpuploadResponseHTtpheaders +} +pub fn (o &CCloudBeginHTtpuploadResponse) pack() []byte { +mut res := []byte{} +if o.has_ugcid { +res << vproto.pack_64bit_field(o.ugcid, 1) +} + +if o.has_timestamp { +res << vproto.pack_32bit_field(o.timestamp, 2) +} + +if o.has_url_host { +res << vproto.pack_string_field(o.url_host, 3) +} + +if o.has_url_path { +res << vproto.pack_string_field(o.url_path, 4) +} + +if o.has_use_https { +res << vproto.pack_bool_field(o.use_https, 5) +} + +// [packed=false] +for _, x in o.request_headers { +res << zzz_vproto_internal_pack_ccloudbeginhttpuploadresponsehttpheaders(x, 6) +} + +return res +} + +pub fn ccloudbeginhttpuploadresponse_unpack(buf []byte) ?CCloudBeginHTtpuploadResponse { +mut res := CCloudBeginHTtpuploadResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_ugcid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.ugcid = v +i = ii +} + +2 { +res.has_timestamp = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp = v +i = ii +} + +3 { +res.has_url_host = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url_host = v +i = ii +} + +4 { +res.has_url_path = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url_path = v +i = ii +} + +5 { +res.has_use_https = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.use_https = v +i = ii +} + +6 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_ccloudbeginhttpuploadresponsehttpheaders(cur_buf, tag_wiretype.wire_type)? +res.request_headers << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudbeginhttpuploadresponse() CCloudBeginHTtpuploadResponse { +return CCloudBeginHTtpuploadResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudbeginhttpuploadresponse(o CCloudBeginHTtpuploadResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudbeginhttpuploadresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudBeginHTtpuploadResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudbeginhttpuploadresponse_unpack(v)? +return i, unpacked +} +pub struct CCloudCommitHTtpuploadRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +transfer_succeeded bool +has_transfer_succeeded bool +appid u32 +has_appid bool +file_sha string +has_file_sha bool +filename string +has_filename bool +} +pub fn (o &CCloudCommitHTtpuploadRequest) pack() []byte { +mut res := []byte{} +if o.has_transfer_succeeded { +res << vproto.pack_bool_field(o.transfer_succeeded, 1) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 2) +} + +if o.has_file_sha { +res << vproto.pack_string_field(o.file_sha, 3) +} + +if o.has_filename { +res << vproto.pack_string_field(o.filename, 4) +} + +return res +} + +pub fn ccloudcommithttpuploadrequest_unpack(buf []byte) ?CCloudCommitHTtpuploadRequest { +mut res := CCloudCommitHTtpuploadRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_transfer_succeeded = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.transfer_succeeded = v +i = ii +} + +2 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +3 { +res.has_file_sha = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.file_sha = v +i = ii +} + +4 { +res.has_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.filename = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudcommithttpuploadrequest() CCloudCommitHTtpuploadRequest { +return CCloudCommitHTtpuploadRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudcommithttpuploadrequest(o CCloudCommitHTtpuploadRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudcommithttpuploadrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudCommitHTtpuploadRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudcommithttpuploadrequest_unpack(v)? +return i, unpacked +} +pub struct CCloudCommitHTtpuploadResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +file_committed bool +has_file_committed bool +} +pub fn (o &CCloudCommitHTtpuploadResponse) pack() []byte { +mut res := []byte{} +if o.has_file_committed { +res << vproto.pack_bool_field(o.file_committed, 1) +} + +return res +} + +pub fn ccloudcommithttpuploadresponse_unpack(buf []byte) ?CCloudCommitHTtpuploadResponse { +mut res := CCloudCommitHTtpuploadResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_file_committed = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.file_committed = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudcommithttpuploadresponse() CCloudCommitHTtpuploadResponse { +return CCloudCommitHTtpuploadResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudcommithttpuploadresponse(o CCloudCommitHTtpuploadResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudcommithttpuploadresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudCommitHTtpuploadResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudcommithttpuploadresponse_unpack(v)? +return i, unpacked +} +pub struct CCloudGetFileDetailsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +ugcid u64 +has_ugcid bool +appid u32 +has_appid bool +} +pub fn (o &CCloudGetFileDetailsRequest) pack() []byte { +mut res := []byte{} +if o.has_ugcid { +res << vproto.pack_uint64_field(o.ugcid, 1) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 2) +} + +return res +} + +pub fn ccloudgetfiledetailsrequest_unpack(buf []byte) ?CCloudGetFileDetailsRequest { +mut res := CCloudGetFileDetailsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_ugcid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.ugcid = v +i = ii +} + +2 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudgetfiledetailsrequest() CCloudGetFileDetailsRequest { +return CCloudGetFileDetailsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudgetfiledetailsrequest(o CCloudGetFileDetailsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudgetfiledetailsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudGetFileDetailsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudgetfiledetailsrequest_unpack(v)? +return i, unpacked +} +pub struct CCloudUserFile { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +ugcid u64 +has_ugcid bool +filename string +has_filename bool +timestamp u64 +has_timestamp bool +file_size u32 +has_file_size bool +url string +has_url bool +steamid_creator u64 +has_steamid_creator bool +flags u32 +has_flags bool +platforms_to_sync []string +file_sha string +has_file_sha bool +} +pub fn (o &CCloudUserFile) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_ugcid { +res << vproto.pack_uint64_field(o.ugcid, 2) +} + +if o.has_filename { +res << vproto.pack_string_field(o.filename, 3) +} + +if o.has_timestamp { +res << vproto.pack_uint64_field(o.timestamp, 4) +} + +if o.has_file_size { +res << vproto.pack_uint32_field(o.file_size, 5) +} + +if o.has_url { +res << vproto.pack_string_field(o.url, 6) +} + +if o.has_steamid_creator { +res << vproto.pack_64bit_field(o.steamid_creator, 7) +} + +if o.has_flags { +res << vproto.pack_uint32_field(o.flags, 8) +} + +// [packed=false] +for _, x in o.platforms_to_sync { +res << vproto.pack_string_field(x, 9) +} + +if o.has_file_sha { +res << vproto.pack_string_field(o.file_sha, 10) +} + +return res +} + +pub fn cclouduserfile_unpack(buf []byte) ?CCloudUserFile { +mut res := CCloudUserFile{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_ugcid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.ugcid = v +i = ii +} + +3 { +res.has_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.filename = v +i = ii +} + +4 { +res.has_timestamp = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp = v +i = ii +} + +5 { +res.has_file_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.file_size = v +i = ii +} + +6 { +res.has_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url = v +i = ii +} + +7 { +res.has_steamid_creator = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_creator = v +i = ii +} + +8 { +res.has_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.flags = v +i = ii +} + +9 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.platforms_to_sync << v +i = ii +} + +10 { +res.has_file_sha = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.file_sha = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cclouduserfile() CCloudUserFile { +return CCloudUserFile{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cclouduserfile(o CCloudUserFile, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cclouduserfile(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudUserFile) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cclouduserfile_unpack(v)? +return i, unpacked +} +pub struct CCloudGetFileDetailsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +details CCloudUserFile +has_details bool +} +pub fn (o &CCloudGetFileDetailsResponse) pack() []byte { +mut res := []byte{} +if o.has_details { +res << zzz_vproto_internal_pack_cclouduserfile(o.details, 1) +} + +return res +} + +pub fn ccloudgetfiledetailsresponse_unpack(buf []byte) ?CCloudGetFileDetailsResponse { +mut res := CCloudGetFileDetailsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_details = true +ii, v := zzz_vproto_internal_unpack_cclouduserfile(cur_buf, tag_wiretype.wire_type)? +res.details = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudgetfiledetailsresponse() CCloudGetFileDetailsResponse { +return CCloudGetFileDetailsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudgetfiledetailsresponse(o CCloudGetFileDetailsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudgetfiledetailsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudGetFileDetailsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudgetfiledetailsresponse_unpack(v)? +return i, unpacked +} +pub struct CCloudEnumerateUserFilesRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +extended_details bool +has_extended_details bool +count u32 +has_count bool +start_index u32 +has_start_index bool +} +pub fn (o &CCloudEnumerateUserFilesRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_extended_details { +res << vproto.pack_bool_field(o.extended_details, 2) +} + +if o.has_count { +res << vproto.pack_uint32_field(o.count, 3) +} + +if o.has_start_index { +res << vproto.pack_uint32_field(o.start_index, 4) +} + +return res +} + +pub fn ccloudenumerateuserfilesrequest_unpack(buf []byte) ?CCloudEnumerateUserFilesRequest { +mut res := CCloudEnumerateUserFilesRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_extended_details = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.extended_details = v +i = ii +} + +3 { +res.has_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.count = v +i = ii +} + +4 { +res.has_start_index = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.start_index = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudenumerateuserfilesrequest() CCloudEnumerateUserFilesRequest { +return CCloudEnumerateUserFilesRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudenumerateuserfilesrequest(o CCloudEnumerateUserFilesRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudenumerateuserfilesrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudEnumerateUserFilesRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudenumerateuserfilesrequest_unpack(v)? +return i, unpacked +} +pub struct CCloudEnumerateUserFilesResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +files []CCloudUserFile +total_files u32 +has_total_files bool +} +pub fn (o &CCloudEnumerateUserFilesResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.files { +res << zzz_vproto_internal_pack_cclouduserfile(x, 1) +} + +if o.has_total_files { +res << vproto.pack_uint32_field(o.total_files, 2) +} + +return res +} + +pub fn ccloudenumerateuserfilesresponse_unpack(buf []byte) ?CCloudEnumerateUserFilesResponse { +mut res := CCloudEnumerateUserFilesResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cclouduserfile(cur_buf, tag_wiretype.wire_type)? +res.files << v +i = ii +} + +2 { +res.has_total_files = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.total_files = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudenumerateuserfilesresponse() CCloudEnumerateUserFilesResponse { +return CCloudEnumerateUserFilesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudenumerateuserfilesresponse(o CCloudEnumerateUserFilesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudenumerateuserfilesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudEnumerateUserFilesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudenumerateuserfilesresponse_unpack(v)? +return i, unpacked +} +pub struct CCloudDeleteRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +filename string +has_filename bool +appid u32 +has_appid bool +} +pub fn (o &CCloudDeleteRequest) pack() []byte { +mut res := []byte{} +if o.has_filename { +res << vproto.pack_string_field(o.filename, 1) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 2) +} + +return res +} + +pub fn cclouddeleterequest_unpack(buf []byte) ?CCloudDeleteRequest { +mut res := CCloudDeleteRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.filename = v +i = ii +} + +2 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cclouddeleterequest() CCloudDeleteRequest { +return CCloudDeleteRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cclouddeleterequest(o CCloudDeleteRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cclouddeleterequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudDeleteRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cclouddeleterequest_unpack(v)? +return i, unpacked +} +pub struct CCloudDeleteResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CCloudDeleteResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cclouddeleteresponse_unpack(buf []byte) ?CCloudDeleteResponse { +res := CCloudDeleteResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cclouddeleteresponse() CCloudDeleteResponse { +return CCloudDeleteResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cclouddeleteresponse(o CCloudDeleteResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cclouddeleteresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudDeleteResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cclouddeleteresponse_unpack(v)? +return i, unpacked +} +pub struct CCloudGetClientEncryptionKeyRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CCloudGetClientEncryptionKeyRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn ccloudgetclientencryptionkeyrequest_unpack(buf []byte) ?CCloudGetClientEncryptionKeyRequest { +res := CCloudGetClientEncryptionKeyRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudgetclientencryptionkeyrequest() CCloudGetClientEncryptionKeyRequest { +return CCloudGetClientEncryptionKeyRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudgetclientencryptionkeyrequest(o CCloudGetClientEncryptionKeyRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudgetclientencryptionkeyrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudGetClientEncryptionKeyRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudgetclientencryptionkeyrequest_unpack(v)? +return i, unpacked +} +pub struct CCloudGetClientEncryptionKeyResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +key []byte +has_key bool +crc int +has_crc bool +} +pub fn (o &CCloudGetClientEncryptionKeyResponse) pack() []byte { +mut res := []byte{} +if o.has_key { +res << vproto.pack_bytes_field(o.key, 1) +} + +if o.has_crc { +res << vproto.pack_int32_field(o.crc, 2) +} + +return res +} + +pub fn ccloudgetclientencryptionkeyresponse_unpack(buf []byte) ?CCloudGetClientEncryptionKeyResponse { +mut res := CCloudGetClientEncryptionKeyResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_key = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.key = v +i = ii +} + +2 { +res.has_crc = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.crc = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudgetclientencryptionkeyresponse() CCloudGetClientEncryptionKeyResponse { +return CCloudGetClientEncryptionKeyResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudgetclientencryptionkeyresponse(o CCloudGetClientEncryptionKeyResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudgetclientencryptionkeyresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudGetClientEncryptionKeyResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudgetclientencryptionkeyresponse_unpack(v)? +return i, unpacked +} +pub struct CCloudCDnreportNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +url string +has_url bool +success bool +has_success bool +http_status_code u32 +has_http_status_code bool +expected_bytes u64 +has_expected_bytes bool +received_bytes u64 +has_received_bytes bool +duration u32 +has_duration bool +} +pub fn (o &CCloudCDnreportNotification) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_url { +res << vproto.pack_string_field(o.url, 2) +} + +if o.has_success { +res << vproto.pack_bool_field(o.success, 3) +} + +if o.has_http_status_code { +res << vproto.pack_uint32_field(o.http_status_code, 4) +} + +if o.has_expected_bytes { +res << vproto.pack_uint64_field(o.expected_bytes, 5) +} + +if o.has_received_bytes { +res << vproto.pack_uint64_field(o.received_bytes, 6) +} + +if o.has_duration { +res << vproto.pack_uint32_field(o.duration, 7) +} + +return res +} + +pub fn ccloudcdnreportnotification_unpack(buf []byte) ?CCloudCDnreportNotification { +mut res := CCloudCDnreportNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url = v +i = ii +} + +3 { +res.has_success = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.success = v +i = ii +} + +4 { +res.has_http_status_code = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.http_status_code = v +i = ii +} + +5 { +res.has_expected_bytes = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.expected_bytes = v +i = ii +} + +6 { +res.has_received_bytes = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.received_bytes = v +i = ii +} + +7 { +res.has_duration = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.duration = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudcdnreportnotification() CCloudCDnreportNotification { +return CCloudCDnreportNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudcdnreportnotification(o CCloudCDnreportNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudcdnreportnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudCDnreportNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudcdnreportnotification_unpack(v)? +return i, unpacked +} +pub struct CCloudExternalStorageTransferReportNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +host string +has_host bool +path string +has_path bool +is_upload bool +has_is_upload bool +success bool +has_success bool +http_status_code u32 +has_http_status_code bool +bytes_expected u64 +has_bytes_expected bool +bytes_actual u64 +has_bytes_actual bool +duration_ms u32 +has_duration_ms bool +cellid u32 +has_cellid bool +proxied bool +has_proxied bool +ipv6_local bool +has_ipv6_local bool +ipv6_remote bool +has_ipv6_remote bool +} +pub fn (o &CCloudExternalStorageTransferReportNotification) pack() []byte { +mut res := []byte{} +if o.has_host { +res << vproto.pack_string_field(o.host, 1) +} + +if o.has_path { +res << vproto.pack_string_field(o.path, 2) +} + +if o.has_is_upload { +res << vproto.pack_bool_field(o.is_upload, 3) +} + +if o.has_success { +res << vproto.pack_bool_field(o.success, 4) +} + +if o.has_http_status_code { +res << vproto.pack_uint32_field(o.http_status_code, 5) +} + +if o.has_bytes_expected { +res << vproto.pack_uint64_field(o.bytes_expected, 6) +} + +if o.has_bytes_actual { +res << vproto.pack_uint64_field(o.bytes_actual, 7) +} + +if o.has_duration_ms { +res << vproto.pack_uint32_field(o.duration_ms, 8) +} + +if o.has_cellid { +res << vproto.pack_uint32_field(o.cellid, 9) +} + +if o.has_proxied { +res << vproto.pack_bool_field(o.proxied, 10) +} + +if o.has_ipv6_local { +res << vproto.pack_bool_field(o.ipv6_local, 11) +} + +if o.has_ipv6_remote { +res << vproto.pack_bool_field(o.ipv6_remote, 12) +} + +return res +} + +pub fn ccloudexternalstoragetransferreportnotification_unpack(buf []byte) ?CCloudExternalStorageTransferReportNotification { +mut res := CCloudExternalStorageTransferReportNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_host = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.host = v +i = ii +} + +2 { +res.has_path = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.path = v +i = ii +} + +3 { +res.has_is_upload = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_upload = v +i = ii +} + +4 { +res.has_success = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.success = v +i = ii +} + +5 { +res.has_http_status_code = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.http_status_code = v +i = ii +} + +6 { +res.has_bytes_expected = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.bytes_expected = v +i = ii +} + +7 { +res.has_bytes_actual = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.bytes_actual = v +i = ii +} + +8 { +res.has_duration_ms = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.duration_ms = v +i = ii +} + +9 { +res.has_cellid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cellid = v +i = ii +} + +10 { +res.has_proxied = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.proxied = v +i = ii +} + +11 { +res.has_ipv6_local = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.ipv6_local = v +i = ii +} + +12 { +res.has_ipv6_remote = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.ipv6_remote = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudexternalstoragetransferreportnotification() CCloudExternalStorageTransferReportNotification { +return CCloudExternalStorageTransferReportNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudexternalstoragetransferreportnotification(o CCloudExternalStorageTransferReportNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudexternalstoragetransferreportnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudExternalStorageTransferReportNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudexternalstoragetransferreportnotification_unpack(v)? +return i, unpacked +} +pub struct CCloudClientBeginFileUploadRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +file_size u32 +has_file_size bool +raw_file_size u32 +has_raw_file_size bool +file_sha []byte +has_file_sha bool +time_stamp u64 +has_time_stamp bool +filename string +has_filename bool +platforms_to_sync u32 +has_platforms_to_sync bool +cell_id u32 +has_cell_id bool +can_encrypt bool +has_can_encrypt bool +is_shared_file bool +has_is_shared_file bool +realm u32 +has_realm bool +} +pub fn (o &CCloudClientBeginFileUploadRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_file_size { +res << vproto.pack_uint32_field(o.file_size, 2) +} + +if o.has_raw_file_size { +res << vproto.pack_uint32_field(o.raw_file_size, 3) +} + +if o.has_file_sha { +res << vproto.pack_bytes_field(o.file_sha, 4) +} + +if o.has_time_stamp { +res << vproto.pack_uint64_field(o.time_stamp, 5) +} + +if o.has_filename { +res << vproto.pack_string_field(o.filename, 6) +} + +if o.has_platforms_to_sync { +res << vproto.pack_uint32_field(o.platforms_to_sync, 7) +} + +if o.has_cell_id { +res << vproto.pack_uint32_field(o.cell_id, 9) +} + +if o.has_can_encrypt { +res << vproto.pack_bool_field(o.can_encrypt, 10) +} + +if o.has_is_shared_file { +res << vproto.pack_bool_field(o.is_shared_file, 11) +} + +if o.has_realm { +res << vproto.pack_uint32_field(o.realm, 12) +} + +return res +} + +pub fn ccloudclientbeginfileuploadrequest_unpack(buf []byte) ?CCloudClientBeginFileUploadRequest { +mut res := CCloudClientBeginFileUploadRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_file_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.file_size = v +i = ii +} + +3 { +res.has_raw_file_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.raw_file_size = v +i = ii +} + +4 { +res.has_file_sha = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.file_sha = v +i = ii +} + +5 { +res.has_time_stamp = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.time_stamp = v +i = ii +} + +6 { +res.has_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.filename = v +i = ii +} + +7 { +res.has_platforms_to_sync = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.platforms_to_sync = v +i = ii +} + +9 { +res.has_cell_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cell_id = v +i = ii +} + +10 { +res.has_can_encrypt = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.can_encrypt = v +i = ii +} + +11 { +res.has_is_shared_file = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_shared_file = v +i = ii +} + +12 { +res.has_realm = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.realm = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudclientbeginfileuploadrequest() CCloudClientBeginFileUploadRequest { +return CCloudClientBeginFileUploadRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudclientbeginfileuploadrequest(o CCloudClientBeginFileUploadRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudclientbeginfileuploadrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudClientBeginFileUploadRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudclientbeginfileuploadrequest_unpack(v)? +return i, unpacked +} +pub struct ClientCloudFileUploadBlockDetailsHTtpheaders { +mut: +unknown_fields []vproto.UnknownField +pub mut: +name string +has_name bool +value string +has_value bool +} +pub fn (o &ClientCloudFileUploadBlockDetailsHTtpheaders) pack() []byte { +mut res := []byte{} +if o.has_name { +res << vproto.pack_string_field(o.name, 1) +} + +if o.has_value { +res << vproto.pack_string_field(o.value, 2) +} + +return res +} + +pub fn clientcloudfileuploadblockdetailshttpheaders_unpack(buf []byte) ?ClientCloudFileUploadBlockDetailsHTtpheaders { +mut res := ClientCloudFileUploadBlockDetailsHTtpheaders{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +2 { +res.has_value = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.value = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_clientcloudfileuploadblockdetailshttpheaders() ClientCloudFileUploadBlockDetailsHTtpheaders { +return ClientCloudFileUploadBlockDetailsHTtpheaders{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_clientcloudfileuploadblockdetailshttpheaders(o ClientCloudFileUploadBlockDetailsHTtpheaders, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_clientcloudfileuploadblockdetailshttpheaders(buf []byte, tag_wiretype vproto.WireType) ?(int, ClientCloudFileUploadBlockDetailsHTtpheaders) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := clientcloudfileuploadblockdetailshttpheaders_unpack(v)? +return i, unpacked +} +pub struct ClientCloudFileUploadBlockDetails { +mut: +unknown_fields []vproto.UnknownField +pub mut: +url_host string +has_url_host bool +url_path string +has_url_path bool +use_https bool +has_use_https bool +http_method int +has_http_method bool +request_headers []ClientCloudFileUploadBlockDetailsHTtpheaders +block_offset u64 +has_block_offset bool +block_length u32 +has_block_length bool +explicit_body_data []byte +has_explicit_body_data bool +may_parallelize bool +has_may_parallelize bool +} +pub fn (o &ClientCloudFileUploadBlockDetails) pack() []byte { +mut res := []byte{} +if o.has_url_host { +res << vproto.pack_string_field(o.url_host, 1) +} + +if o.has_url_path { +res << vproto.pack_string_field(o.url_path, 2) +} + +if o.has_use_https { +res << vproto.pack_bool_field(o.use_https, 3) +} + +if o.has_http_method { +res << vproto.pack_int32_field(o.http_method, 4) +} + +// [packed=false] +for _, x in o.request_headers { +res << zzz_vproto_internal_pack_clientcloudfileuploadblockdetailshttpheaders(x, 5) +} + +if o.has_block_offset { +res << vproto.pack_uint64_field(o.block_offset, 6) +} + +if o.has_block_length { +res << vproto.pack_uint32_field(o.block_length, 7) +} + +if o.has_explicit_body_data { +res << vproto.pack_bytes_field(o.explicit_body_data, 8) +} + +if o.has_may_parallelize { +res << vproto.pack_bool_field(o.may_parallelize, 9) +} + +return res +} + +pub fn clientcloudfileuploadblockdetails_unpack(buf []byte) ?ClientCloudFileUploadBlockDetails { +mut res := ClientCloudFileUploadBlockDetails{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_url_host = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url_host = v +i = ii +} + +2 { +res.has_url_path = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url_path = v +i = ii +} + +3 { +res.has_use_https = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.use_https = v +i = ii +} + +4 { +res.has_http_method = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.http_method = v +i = ii +} + +5 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_clientcloudfileuploadblockdetailshttpheaders(cur_buf, tag_wiretype.wire_type)? +res.request_headers << v +i = ii +} + +6 { +res.has_block_offset = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.block_offset = v +i = ii +} + +7 { +res.has_block_length = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.block_length = v +i = ii +} + +8 { +res.has_explicit_body_data = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.explicit_body_data = v +i = ii +} + +9 { +res.has_may_parallelize = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.may_parallelize = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_clientcloudfileuploadblockdetails() ClientCloudFileUploadBlockDetails { +return ClientCloudFileUploadBlockDetails{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_clientcloudfileuploadblockdetails(o ClientCloudFileUploadBlockDetails, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_clientcloudfileuploadblockdetails(buf []byte, tag_wiretype vproto.WireType) ?(int, ClientCloudFileUploadBlockDetails) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := clientcloudfileuploadblockdetails_unpack(v)? +return i, unpacked +} +pub struct CCloudClientBeginFileUploadResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +encrypt_file bool +has_encrypt_file bool +block_requests []ClientCloudFileUploadBlockDetails +} +pub fn (o &CCloudClientBeginFileUploadResponse) pack() []byte { +mut res := []byte{} +if o.has_encrypt_file { +res << vproto.pack_bool_field(o.encrypt_file, 1) +} + +// [packed=false] +for _, x in o.block_requests { +res << zzz_vproto_internal_pack_clientcloudfileuploadblockdetails(x, 2) +} + +return res +} + +pub fn ccloudclientbeginfileuploadresponse_unpack(buf []byte) ?CCloudClientBeginFileUploadResponse { +mut res := CCloudClientBeginFileUploadResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_encrypt_file = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.encrypt_file = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_clientcloudfileuploadblockdetails(cur_buf, tag_wiretype.wire_type)? +res.block_requests << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudclientbeginfileuploadresponse() CCloudClientBeginFileUploadResponse { +return CCloudClientBeginFileUploadResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudclientbeginfileuploadresponse(o CCloudClientBeginFileUploadResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudclientbeginfileuploadresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudClientBeginFileUploadResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudclientbeginfileuploadresponse_unpack(v)? +return i, unpacked +} +pub struct CCloudClientCommitFileUploadRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +transfer_succeeded bool +has_transfer_succeeded bool +appid u32 +has_appid bool +file_sha []byte +has_file_sha bool +filename string +has_filename bool +} +pub fn (o &CCloudClientCommitFileUploadRequest) pack() []byte { +mut res := []byte{} +if o.has_transfer_succeeded { +res << vproto.pack_bool_field(o.transfer_succeeded, 1) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 2) +} + +if o.has_file_sha { +res << vproto.pack_bytes_field(o.file_sha, 3) +} + +if o.has_filename { +res << vproto.pack_string_field(o.filename, 4) +} + +return res +} + +pub fn ccloudclientcommitfileuploadrequest_unpack(buf []byte) ?CCloudClientCommitFileUploadRequest { +mut res := CCloudClientCommitFileUploadRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_transfer_succeeded = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.transfer_succeeded = v +i = ii +} + +2 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +3 { +res.has_file_sha = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.file_sha = v +i = ii +} + +4 { +res.has_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.filename = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudclientcommitfileuploadrequest() CCloudClientCommitFileUploadRequest { +return CCloudClientCommitFileUploadRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudclientcommitfileuploadrequest(o CCloudClientCommitFileUploadRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudclientcommitfileuploadrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudClientCommitFileUploadRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudclientcommitfileuploadrequest_unpack(v)? +return i, unpacked +} +pub struct CCloudClientCommitFileUploadResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +file_committed bool +has_file_committed bool +} +pub fn (o &CCloudClientCommitFileUploadResponse) pack() []byte { +mut res := []byte{} +if o.has_file_committed { +res << vproto.pack_bool_field(o.file_committed, 1) +} + +return res +} + +pub fn ccloudclientcommitfileuploadresponse_unpack(buf []byte) ?CCloudClientCommitFileUploadResponse { +mut res := CCloudClientCommitFileUploadResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_file_committed = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.file_committed = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudclientcommitfileuploadresponse() CCloudClientCommitFileUploadResponse { +return CCloudClientCommitFileUploadResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudclientcommitfileuploadresponse(o CCloudClientCommitFileUploadResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudclientcommitfileuploadresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudClientCommitFileUploadResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudclientcommitfileuploadresponse_unpack(v)? +return i, unpacked +} +pub struct CCloudClientFileDownloadRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +filename string +has_filename bool +realm u32 +has_realm bool +} +pub fn (o &CCloudClientFileDownloadRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_filename { +res << vproto.pack_string_field(o.filename, 2) +} + +if o.has_realm { +res << vproto.pack_uint32_field(o.realm, 3) +} + +return res +} + +pub fn ccloudclientfiledownloadrequest_unpack(buf []byte) ?CCloudClientFileDownloadRequest { +mut res := CCloudClientFileDownloadRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.filename = v +i = ii +} + +3 { +res.has_realm = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.realm = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudclientfiledownloadrequest() CCloudClientFileDownloadRequest { +return CCloudClientFileDownloadRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudclientfiledownloadrequest(o CCloudClientFileDownloadRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudclientfiledownloadrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudClientFileDownloadRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudclientfiledownloadrequest_unpack(v)? +return i, unpacked +} +pub struct CCloudClientFileDownloadResponseHTtpheaders { +mut: +unknown_fields []vproto.UnknownField +pub mut: +name string +has_name bool +value string +has_value bool +} +pub fn (o &CCloudClientFileDownloadResponseHTtpheaders) pack() []byte { +mut res := []byte{} +if o.has_name { +res << vproto.pack_string_field(o.name, 1) +} + +if o.has_value { +res << vproto.pack_string_field(o.value, 2) +} + +return res +} + +pub fn ccloudclientfiledownloadresponsehttpheaders_unpack(buf []byte) ?CCloudClientFileDownloadResponseHTtpheaders { +mut res := CCloudClientFileDownloadResponseHTtpheaders{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +2 { +res.has_value = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.value = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudclientfiledownloadresponsehttpheaders() CCloudClientFileDownloadResponseHTtpheaders { +return CCloudClientFileDownloadResponseHTtpheaders{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudclientfiledownloadresponsehttpheaders(o CCloudClientFileDownloadResponseHTtpheaders, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudclientfiledownloadresponsehttpheaders(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudClientFileDownloadResponseHTtpheaders) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudclientfiledownloadresponsehttpheaders_unpack(v)? +return i, unpacked +} +pub struct CCloudClientFileDownloadResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +file_size u32 +has_file_size bool +raw_file_size u32 +has_raw_file_size bool +sha_file []byte +has_sha_file bool +time_stamp u64 +has_time_stamp bool +is_explicit_delete bool +has_is_explicit_delete bool +url_host string +has_url_host bool +url_path string +has_url_path bool +use_https bool +has_use_https bool +request_headers []CCloudClientFileDownloadResponseHTtpheaders +encrypted bool +has_encrypted bool +} +pub fn (o &CCloudClientFileDownloadResponse) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_file_size { +res << vproto.pack_uint32_field(o.file_size, 2) +} + +if o.has_raw_file_size { +res << vproto.pack_uint32_field(o.raw_file_size, 3) +} + +if o.has_sha_file { +res << vproto.pack_bytes_field(o.sha_file, 4) +} + +if o.has_time_stamp { +res << vproto.pack_uint64_field(o.time_stamp, 5) +} + +if o.has_is_explicit_delete { +res << vproto.pack_bool_field(o.is_explicit_delete, 6) +} + +if o.has_url_host { +res << vproto.pack_string_field(o.url_host, 7) +} + +if o.has_url_path { +res << vproto.pack_string_field(o.url_path, 8) +} + +if o.has_use_https { +res << vproto.pack_bool_field(o.use_https, 9) +} + +// [packed=false] +for _, x in o.request_headers { +res << zzz_vproto_internal_pack_ccloudclientfiledownloadresponsehttpheaders(x, 10) +} + +if o.has_encrypted { +res << vproto.pack_bool_field(o.encrypted, 11) +} + +return res +} + +pub fn ccloudclientfiledownloadresponse_unpack(buf []byte) ?CCloudClientFileDownloadResponse { +mut res := CCloudClientFileDownloadResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_file_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.file_size = v +i = ii +} + +3 { +res.has_raw_file_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.raw_file_size = v +i = ii +} + +4 { +res.has_sha_file = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha_file = v +i = ii +} + +5 { +res.has_time_stamp = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.time_stamp = v +i = ii +} + +6 { +res.has_is_explicit_delete = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_explicit_delete = v +i = ii +} + +7 { +res.has_url_host = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url_host = v +i = ii +} + +8 { +res.has_url_path = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url_path = v +i = ii +} + +9 { +res.has_use_https = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.use_https = v +i = ii +} + +10 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_ccloudclientfiledownloadresponsehttpheaders(cur_buf, tag_wiretype.wire_type)? +res.request_headers << v +i = ii +} + +11 { +res.has_encrypted = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.encrypted = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudclientfiledownloadresponse() CCloudClientFileDownloadResponse { +return CCloudClientFileDownloadResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudclientfiledownloadresponse(o CCloudClientFileDownloadResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudclientfiledownloadresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudClientFileDownloadResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudclientfiledownloadresponse_unpack(v)? +return i, unpacked +} +pub struct CCloudClientDeleteFileRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +filename string +has_filename bool +is_explicit_delete bool +has_is_explicit_delete bool +} +pub fn (o &CCloudClientDeleteFileRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_filename { +res << vproto.pack_string_field(o.filename, 2) +} + +if o.has_is_explicit_delete { +res << vproto.pack_bool_field(o.is_explicit_delete, 3) +} + +return res +} + +pub fn ccloudclientdeletefilerequest_unpack(buf []byte) ?CCloudClientDeleteFileRequest { +mut res := CCloudClientDeleteFileRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.filename = v +i = ii +} + +3 { +res.has_is_explicit_delete = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_explicit_delete = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudclientdeletefilerequest() CCloudClientDeleteFileRequest { +return CCloudClientDeleteFileRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudclientdeletefilerequest(o CCloudClientDeleteFileRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudclientdeletefilerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudClientDeleteFileRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudclientdeletefilerequest_unpack(v)? +return i, unpacked +} +pub struct CCloudClientDeleteFileResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CCloudClientDeleteFileResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn ccloudclientdeletefileresponse_unpack(buf []byte) ?CCloudClientDeleteFileResponse { +res := CCloudClientDeleteFileResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudclientdeletefileresponse() CCloudClientDeleteFileResponse { +return CCloudClientDeleteFileResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudclientdeletefileresponse(o CCloudClientDeleteFileResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudclientdeletefileresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudClientDeleteFileResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudclientdeletefileresponse_unpack(v)? +return i, unpacked +} +pub struct CCloudClientConflictResolutionNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +chose_local_files bool +has_chose_local_files bool +} +pub fn (o &CCloudClientConflictResolutionNotification) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_chose_local_files { +res << vproto.pack_bool_field(o.chose_local_files, 2) +} + +return res +} + +pub fn ccloudclientconflictresolutionnotification_unpack(buf []byte) ?CCloudClientConflictResolutionNotification { +mut res := CCloudClientConflictResolutionNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_chose_local_files = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.chose_local_files = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudclientconflictresolutionnotification() CCloudClientConflictResolutionNotification { +return CCloudClientConflictResolutionNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudclientconflictresolutionnotification(o CCloudClientConflictResolutionNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudclientconflictresolutionnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudClientConflictResolutionNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudclientconflictresolutionnotification_unpack(v)? +return i, unpacked +} +pub struct CCloudEnumerateUserAppsRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CCloudEnumerateUserAppsRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn ccloudenumerateuserappsrequest_unpack(buf []byte) ?CCloudEnumerateUserAppsRequest { +res := CCloudEnumerateUserAppsRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudenumerateuserappsrequest() CCloudEnumerateUserAppsRequest { +return CCloudEnumerateUserAppsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudenumerateuserappsrequest(o CCloudEnumerateUserAppsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudenumerateuserappsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudEnumerateUserAppsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudenumerateuserappsrequest_unpack(v)? +return i, unpacked +} +pub struct CCloudEnumerateUserAppsResponseApps { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +totalcount int +has_totalcount bool +totalsize i64 +has_totalsize bool +} +pub fn (o &CCloudEnumerateUserAppsResponseApps) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_totalcount { +res << vproto.pack_int32_field(o.totalcount, 2) +} + +if o.has_totalsize { +res << vproto.pack_int64_field(o.totalsize, 3) +} + +return res +} + +pub fn ccloudenumerateuserappsresponseapps_unpack(buf []byte) ?CCloudEnumerateUserAppsResponseApps { +mut res := CCloudEnumerateUserAppsResponseApps{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_totalcount = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.totalcount = v +i = ii +} + +3 { +res.has_totalsize = true +ii, v := vproto.unpack_int64_field(cur_buf, tag_wiretype.wire_type)? +res.totalsize = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudenumerateuserappsresponseapps() CCloudEnumerateUserAppsResponseApps { +return CCloudEnumerateUserAppsResponseApps{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudenumerateuserappsresponseapps(o CCloudEnumerateUserAppsResponseApps, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudenumerateuserappsresponseapps(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudEnumerateUserAppsResponseApps) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudenumerateuserappsresponseapps_unpack(v)? +return i, unpacked +} +pub struct CCloudEnumerateUserAppsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +apps []CCloudEnumerateUserAppsResponseApps +} +pub fn (o &CCloudEnumerateUserAppsResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.apps { +res << zzz_vproto_internal_pack_ccloudenumerateuserappsresponseapps(x, 1) +} + +return res +} + +pub fn ccloudenumerateuserappsresponse_unpack(buf []byte) ?CCloudEnumerateUserAppsResponse { +mut res := CCloudEnumerateUserAppsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_ccloudenumerateuserappsresponseapps(cur_buf, tag_wiretype.wire_type)? +res.apps << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccloudenumerateuserappsresponse() CCloudEnumerateUserAppsResponse { +return CCloudEnumerateUserAppsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccloudenumerateuserappsresponse(o CCloudEnumerateUserAppsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccloudenumerateuserappsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CCloudEnumerateUserAppsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccloudenumerateuserappsresponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_contentsystem.steamclient_pb.v b/proto/steammessages_contentsystem.steamclient_pb.v new file mode 100644 index 0000000..5381775 --- /dev/null +++ b/proto/steammessages_contentsystem.steamclient_pb.v @@ -0,0 +1,544 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CContentServerDirectoryGetServersForSteamPipeRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +cell_id u32 +has_cell_id bool +max_servers u32 +has_max_servers bool +ip_override string +has_ip_override bool +launcher_type int +has_launcher_type bool +} +pub fn (o &CContentServerDirectoryGetServersForSteamPipeRequest) pack() []byte { +mut res := []byte{} +if o.has_cell_id { +res << vproto.pack_uint32_field(o.cell_id, 1) +} + +if o.has_max_servers { +res << vproto.pack_uint32_field(o.max_servers, 2) +} + +if o.has_ip_override { +res << vproto.pack_string_field(o.ip_override, 3) +} + +if o.has_launcher_type { +res << vproto.pack_int32_field(o.launcher_type, 4) +} + +return res +} + +pub fn ccontentserverdirectorygetserversforsteampiperequest_unpack(buf []byte) ?CContentServerDirectoryGetServersForSteamPipeRequest { +mut res := CContentServerDirectoryGetServersForSteamPipeRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_cell_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cell_id = v +i = ii +} + +2 { +res.has_max_servers = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.max_servers = v +i = ii +} + +3 { +res.has_ip_override = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.ip_override = v +i = ii +} + +4 { +res.has_launcher_type = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.launcher_type = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccontentserverdirectorygetserversforsteampiperequest() CContentServerDirectoryGetServersForSteamPipeRequest { +return CContentServerDirectoryGetServersForSteamPipeRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccontentserverdirectorygetserversforsteampiperequest(o CContentServerDirectoryGetServersForSteamPipeRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccontentserverdirectorygetserversforsteampiperequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CContentServerDirectoryGetServersForSteamPipeRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccontentserverdirectorygetserversforsteampiperequest_unpack(v)? +return i, unpacked +} +pub struct CContentServerDirectoryServerInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +@type string +has_type bool +source_id int +has_source_id bool +cell_id int +has_cell_id bool +load int +has_load bool +weighted_load f32 +has_weighted_load bool +num_entries_in_client_list int +has_num_entries_in_client_list bool +steam_china_only bool +has_steam_china_only bool +host string +has_host bool +vhost string +has_vhost bool +use_as_proxy bool +has_use_as_proxy bool +proxy_request_path_template string +has_proxy_request_path_template bool +https_support string +has_https_support bool +allowed_app_ids []u32 +preferred_server bool +has_preferred_server bool +} +pub fn (o &CContentServerDirectoryServerInfo) pack() []byte { +mut res := []byte{} +if o.has_type { +res << vproto.pack_string_field(o.@type, 1) +} + +if o.has_source_id { +res << vproto.pack_int32_field(o.source_id, 2) +} + +if o.has_cell_id { +res << vproto.pack_int32_field(o.cell_id, 3) +} + +if o.has_load { +res << vproto.pack_int32_field(o.load, 4) +} + +if o.has_weighted_load { +res << vproto.pack_float_field(o.weighted_load, 5) +} + +if o.has_num_entries_in_client_list { +res << vproto.pack_int32_field(o.num_entries_in_client_list, 6) +} + +if o.has_steam_china_only { +res << vproto.pack_bool_field(o.steam_china_only, 7) +} + +if o.has_host { +res << vproto.pack_string_field(o.host, 8) +} + +if o.has_vhost { +res << vproto.pack_string_field(o.vhost, 9) +} + +if o.has_use_as_proxy { +res << vproto.pack_bool_field(o.use_as_proxy, 10) +} + +if o.has_proxy_request_path_template { +res << vproto.pack_string_field(o.proxy_request_path_template, 11) +} + +if o.has_https_support { +res << vproto.pack_string_field(o.https_support, 12) +} + +// [packed=false] +for _, x in o.allowed_app_ids { +res << vproto.pack_uint32_field(x, 13) +} + +if o.has_preferred_server { +res << vproto.pack_bool_field(o.preferred_server, 14) +} + +return res +} + +pub fn ccontentserverdirectoryserverinfo_unpack(buf []byte) ?CContentServerDirectoryServerInfo { +mut res := CContentServerDirectoryServerInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_type = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.@type = v +i = ii +} + +2 { +res.has_source_id = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.source_id = v +i = ii +} + +3 { +res.has_cell_id = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.cell_id = v +i = ii +} + +4 { +res.has_load = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.load = v +i = ii +} + +5 { +res.has_weighted_load = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.weighted_load = v +i = ii +} + +6 { +res.has_num_entries_in_client_list = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.num_entries_in_client_list = v +i = ii +} + +7 { +res.has_steam_china_only = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.steam_china_only = v +i = ii +} + +8 { +res.has_host = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.host = v +i = ii +} + +9 { +res.has_vhost = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.vhost = v +i = ii +} + +10 { +res.has_use_as_proxy = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.use_as_proxy = v +i = ii +} + +11 { +res.has_proxy_request_path_template = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.proxy_request_path_template = v +i = ii +} + +12 { +res.has_https_support = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.https_support = v +i = ii +} + +13 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.allowed_app_ids << v +i = ii +} + +14 { +res.has_preferred_server = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.preferred_server = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccontentserverdirectoryserverinfo() CContentServerDirectoryServerInfo { +return CContentServerDirectoryServerInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccontentserverdirectoryserverinfo(o CContentServerDirectoryServerInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccontentserverdirectoryserverinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CContentServerDirectoryServerInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccontentserverdirectoryserverinfo_unpack(v)? +return i, unpacked +} +pub struct CContentServerDirectoryGetServersForSteamPipeResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +servers []CContentServerDirectoryServerInfo +} +pub fn (o &CContentServerDirectoryGetServersForSteamPipeResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.servers { +res << zzz_vproto_internal_pack_ccontentserverdirectoryserverinfo(x, 1) +} + +return res +} + +pub fn ccontentserverdirectorygetserversforsteampiperesponse_unpack(buf []byte) ?CContentServerDirectoryGetServersForSteamPipeResponse { +mut res := CContentServerDirectoryGetServersForSteamPipeResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_ccontentserverdirectoryserverinfo(cur_buf, tag_wiretype.wire_type)? +res.servers << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccontentserverdirectorygetserversforsteampiperesponse() CContentServerDirectoryGetServersForSteamPipeResponse { +return CContentServerDirectoryGetServersForSteamPipeResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccontentserverdirectorygetserversforsteampiperesponse(o CContentServerDirectoryGetServersForSteamPipeResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccontentserverdirectorygetserversforsteampiperesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CContentServerDirectoryGetServersForSteamPipeResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccontentserverdirectorygetserversforsteampiperesponse_unpack(v)? +return i, unpacked +} +pub struct CContentServerDirectoryGetDepotPatchInfoRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +depotid u32 +has_depotid bool +source_manifestid u64 +has_source_manifestid bool +target_manifestid u64 +has_target_manifestid bool +} +pub fn (o &CContentServerDirectoryGetDepotPatchInfoRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_depotid { +res << vproto.pack_uint32_field(o.depotid, 2) +} + +if o.has_source_manifestid { +res << vproto.pack_uint64_field(o.source_manifestid, 3) +} + +if o.has_target_manifestid { +res << vproto.pack_uint64_field(o.target_manifestid, 4) +} + +return res +} + +pub fn ccontentserverdirectorygetdepotpatchinforequest_unpack(buf []byte) ?CContentServerDirectoryGetDepotPatchInfoRequest { +mut res := CContentServerDirectoryGetDepotPatchInfoRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_depotid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.depotid = v +i = ii +} + +3 { +res.has_source_manifestid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.source_manifestid = v +i = ii +} + +4 { +res.has_target_manifestid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.target_manifestid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccontentserverdirectorygetdepotpatchinforequest() CContentServerDirectoryGetDepotPatchInfoRequest { +return CContentServerDirectoryGetDepotPatchInfoRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccontentserverdirectorygetdepotpatchinforequest(o CContentServerDirectoryGetDepotPatchInfoRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccontentserverdirectorygetdepotpatchinforequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CContentServerDirectoryGetDepotPatchInfoRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccontentserverdirectorygetdepotpatchinforequest_unpack(v)? +return i, unpacked +} +pub struct CContentServerDirectoryGetDepotPatchInfoResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +is_available bool +has_is_available bool +} +pub fn (o &CContentServerDirectoryGetDepotPatchInfoResponse) pack() []byte { +mut res := []byte{} +if o.has_is_available { +res << vproto.pack_bool_field(o.is_available, 1) +} + +return res +} + +pub fn ccontentserverdirectorygetdepotpatchinforesponse_unpack(buf []byte) ?CContentServerDirectoryGetDepotPatchInfoResponse { +mut res := CContentServerDirectoryGetDepotPatchInfoResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_is_available = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_available = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccontentserverdirectorygetdepotpatchinforesponse() CContentServerDirectoryGetDepotPatchInfoResponse { +return CContentServerDirectoryGetDepotPatchInfoResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccontentserverdirectorygetdepotpatchinforesponse(o CContentServerDirectoryGetDepotPatchInfoResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccontentserverdirectorygetdepotpatchinforesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CContentServerDirectoryGetDepotPatchInfoResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccontentserverdirectorygetdepotpatchinforesponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_credentials.steamclient_pb.v b/proto/steammessages_credentials.steamclient_pb.v new file mode 100644 index 0000000..b4d8cb1 --- /dev/null +++ b/proto/steammessages_credentials.steamclient_pb.v @@ -0,0 +1,1408 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CCredentialsTestAvailablePasswordRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +password string +has_password bool +sha_digest_password []byte +has_sha_digest_password bool +account_name string +has_account_name bool +} +pub fn (o &CCredentialsTestAvailablePasswordRequest) pack() []byte { +mut res := []byte{} +if o.has_password { +res << vproto.pack_string_field(o.password, 1) +} + +if o.has_sha_digest_password { +res << vproto.pack_bytes_field(o.sha_digest_password, 2) +} + +if o.has_account_name { +res << vproto.pack_string_field(o.account_name, 3) +} + +return res +} + +pub fn ccredentialstestavailablepasswordrequest_unpack(buf []byte) ?CCredentialsTestAvailablePasswordRequest { +mut res := CCredentialsTestAvailablePasswordRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_password = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.password = v +i = ii +} + +2 { +res.has_sha_digest_password = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha_digest_password = v +i = ii +} + +3 { +res.has_account_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.account_name = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccredentialstestavailablepasswordrequest() CCredentialsTestAvailablePasswordRequest { +return CCredentialsTestAvailablePasswordRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccredentialstestavailablepasswordrequest(o CCredentialsTestAvailablePasswordRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccredentialstestavailablepasswordrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CCredentialsTestAvailablePasswordRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccredentialstestavailablepasswordrequest_unpack(v)? +return i, unpacked +} +pub struct CCredentialsTestAvailablePasswordResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +is_valid bool +has_is_valid bool +} +pub fn (o &CCredentialsTestAvailablePasswordResponse) pack() []byte { +mut res := []byte{} +if o.has_is_valid { +res << vproto.pack_bool_field(o.is_valid, 3) +} + +return res +} + +pub fn ccredentialstestavailablepasswordresponse_unpack(buf []byte) ?CCredentialsTestAvailablePasswordResponse { +mut res := CCredentialsTestAvailablePasswordResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +3 { +res.has_is_valid = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_valid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccredentialstestavailablepasswordresponse() CCredentialsTestAvailablePasswordResponse { +return CCredentialsTestAvailablePasswordResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccredentialstestavailablepasswordresponse(o CCredentialsTestAvailablePasswordResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccredentialstestavailablepasswordresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CCredentialsTestAvailablePasswordResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccredentialstestavailablepasswordresponse_unpack(v)? +return i, unpacked +} +pub struct CCredentialsGetSteamGuardDetailsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +include_new_authentications bool +has_include_new_authentications bool +webcookie string +has_webcookie bool +timestamp_minimum_wanted u32 +has_timestamp_minimum_wanted bool +ipaddress int +has_ipaddress bool +} +pub fn (o &CCredentialsGetSteamGuardDetailsRequest) pack() []byte { +mut res := []byte{} +if o.has_include_new_authentications { +res << vproto.pack_bool_field(o.include_new_authentications, 1) +} + +if o.has_webcookie { +res << vproto.pack_string_field(o.webcookie, 2) +} + +if o.has_timestamp_minimum_wanted { +res << vproto.pack_32bit_field(o.timestamp_minimum_wanted, 3) +} + +if o.has_ipaddress { +res << vproto.pack_int32_field(o.ipaddress, 4) +} + +return res +} + +pub fn ccredentialsgetsteamguarddetailsrequest_unpack(buf []byte) ?CCredentialsGetSteamGuardDetailsRequest { +mut res := CCredentialsGetSteamGuardDetailsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_include_new_authentications = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.include_new_authentications = v +i = ii +} + +2 { +res.has_webcookie = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.webcookie = v +i = ii +} + +3 { +res.has_timestamp_minimum_wanted = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp_minimum_wanted = v +i = ii +} + +4 { +res.has_ipaddress = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.ipaddress = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccredentialsgetsteamguarddetailsrequest() CCredentialsGetSteamGuardDetailsRequest { +return CCredentialsGetSteamGuardDetailsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccredentialsgetsteamguarddetailsrequest(o CCredentialsGetSteamGuardDetailsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccredentialsgetsteamguarddetailsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CCredentialsGetSteamGuardDetailsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccredentialsgetsteamguarddetailsrequest_unpack(v)? +return i, unpacked +} +pub struct CCredentialsGetSteamGuardDetailsResponseNewAuthentication { +mut: +unknown_fields []vproto.UnknownField +pub mut: +timestamp_steamguard_enabled u32 +has_timestamp_steamguard_enabled bool +is_web_cookie bool +has_is_web_cookie bool +ipaddress int +has_ipaddress bool +geoloc_info string +has_geoloc_info bool +is_remembered bool +has_is_remembered bool +machine_name_user_supplied string +has_machine_name_user_supplied bool +status int +has_status bool +} +pub fn (o &CCredentialsGetSteamGuardDetailsResponseNewAuthentication) pack() []byte { +mut res := []byte{} +if o.has_timestamp_steamguard_enabled { +res << vproto.pack_32bit_field(o.timestamp_steamguard_enabled, 1) +} + +if o.has_is_web_cookie { +res << vproto.pack_bool_field(o.is_web_cookie, 2) +} + +if o.has_ipaddress { +res << vproto.pack_int32_field(o.ipaddress, 3) +} + +if o.has_geoloc_info { +res << vproto.pack_string_field(o.geoloc_info, 4) +} + +if o.has_is_remembered { +res << vproto.pack_bool_field(o.is_remembered, 5) +} + +if o.has_machine_name_user_supplied { +res << vproto.pack_string_field(o.machine_name_user_supplied, 6) +} + +if o.has_status { +res << vproto.pack_int32_field(o.status, 7) +} + +return res +} + +pub fn ccredentialsgetsteamguarddetailsresponsenewauthentication_unpack(buf []byte) ?CCredentialsGetSteamGuardDetailsResponseNewAuthentication { +mut res := CCredentialsGetSteamGuardDetailsResponseNewAuthentication{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_timestamp_steamguard_enabled = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp_steamguard_enabled = v +i = ii +} + +2 { +res.has_is_web_cookie = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_web_cookie = v +i = ii +} + +3 { +res.has_ipaddress = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.ipaddress = v +i = ii +} + +4 { +res.has_geoloc_info = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.geoloc_info = v +i = ii +} + +5 { +res.has_is_remembered = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_remembered = v +i = ii +} + +6 { +res.has_machine_name_user_supplied = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.machine_name_user_supplied = v +i = ii +} + +7 { +res.has_status = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.status = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccredentialsgetsteamguarddetailsresponsenewauthentication() CCredentialsGetSteamGuardDetailsResponseNewAuthentication { +return CCredentialsGetSteamGuardDetailsResponseNewAuthentication{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccredentialsgetsteamguarddetailsresponsenewauthentication(o CCredentialsGetSteamGuardDetailsResponseNewAuthentication, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccredentialsgetsteamguarddetailsresponsenewauthentication(buf []byte, tag_wiretype vproto.WireType) ?(int, CCredentialsGetSteamGuardDetailsResponseNewAuthentication) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccredentialsgetsteamguarddetailsresponsenewauthentication_unpack(v)? +return i, unpacked +} +pub struct CCredentialsGetSteamGuardDetailsResponseSessionData { +mut: +unknown_fields []vproto.UnknownField +pub mut: +machine_id u64 +has_machine_id bool +machine_name_userchosen string +has_machine_name_userchosen bool +timestamp_machine_steamguard_enabled u32 +has_timestamp_machine_steamguard_enabled bool +authentication_exists_from_geoloc_before_mintime bool +has_authentication_exists_from_geoloc_before_mintime bool +newauthentication []CCredentialsGetSteamGuardDetailsResponseNewAuthentication +authentication_exists_from_same_ip_before_mintime bool +has_authentication_exists_from_same_ip_before_mintime bool +public_ipv4 u32 +has_public_ipv4 bool +public_ip_address string +has_public_ip_address bool +} +pub fn (o &CCredentialsGetSteamGuardDetailsResponseSessionData) pack() []byte { +mut res := []byte{} +if o.has_machine_id { +res << vproto.pack_uint64_field(o.machine_id, 1) +} + +if o.has_machine_name_userchosen { +res << vproto.pack_string_field(o.machine_name_userchosen, 2) +} + +if o.has_timestamp_machine_steamguard_enabled { +res << vproto.pack_32bit_field(o.timestamp_machine_steamguard_enabled, 3) +} + +if o.has_authentication_exists_from_geoloc_before_mintime { +res << vproto.pack_bool_field(o.authentication_exists_from_geoloc_before_mintime, 4) +} + +// [packed=false] +for _, x in o.newauthentication { +res << zzz_vproto_internal_pack_ccredentialsgetsteamguarddetailsresponsenewauthentication(x, 5) +} + +if o.has_authentication_exists_from_same_ip_before_mintime { +res << vproto.pack_bool_field(o.authentication_exists_from_same_ip_before_mintime, 6) +} + +if o.has_public_ipv4 { +res << vproto.pack_uint32_field(o.public_ipv4, 7) +} + +if o.has_public_ip_address { +res << vproto.pack_string_field(o.public_ip_address, 8) +} + +return res +} + +pub fn ccredentialsgetsteamguarddetailsresponsesessiondata_unpack(buf []byte) ?CCredentialsGetSteamGuardDetailsResponseSessionData { +mut res := CCredentialsGetSteamGuardDetailsResponseSessionData{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_machine_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.machine_id = v +i = ii +} + +2 { +res.has_machine_name_userchosen = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.machine_name_userchosen = v +i = ii +} + +3 { +res.has_timestamp_machine_steamguard_enabled = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp_machine_steamguard_enabled = v +i = ii +} + +4 { +res.has_authentication_exists_from_geoloc_before_mintime = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.authentication_exists_from_geoloc_before_mintime = v +i = ii +} + +5 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_ccredentialsgetsteamguarddetailsresponsenewauthentication(cur_buf, tag_wiretype.wire_type)? +res.newauthentication << v +i = ii +} + +6 { +res.has_authentication_exists_from_same_ip_before_mintime = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.authentication_exists_from_same_ip_before_mintime = v +i = ii +} + +7 { +res.has_public_ipv4 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.public_ipv4 = v +i = ii +} + +8 { +res.has_public_ip_address = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.public_ip_address = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccredentialsgetsteamguarddetailsresponsesessiondata() CCredentialsGetSteamGuardDetailsResponseSessionData { +return CCredentialsGetSteamGuardDetailsResponseSessionData{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccredentialsgetsteamguarddetailsresponsesessiondata(o CCredentialsGetSteamGuardDetailsResponseSessionData, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccredentialsgetsteamguarddetailsresponsesessiondata(buf []byte, tag_wiretype vproto.WireType) ?(int, CCredentialsGetSteamGuardDetailsResponseSessionData) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccredentialsgetsteamguarddetailsresponsesessiondata_unpack(v)? +return i, unpacked +} +pub struct CCredentialsGetSteamGuardDetailsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +is_steamguard_enabled bool +has_is_steamguard_enabled bool +timestamp_steamguard_enabled u32 +has_timestamp_steamguard_enabled bool +deprecated_newauthentication []CCredentialsGetSteamGuardDetailsResponseNewAuthentication +deprecated_machine_name_userchosen string +has_deprecated_machine_name_userchosen bool +deprecated_timestamp_machine_steamguard_enabled u32 +has_deprecated_timestamp_machine_steamguard_enabled bool +deprecated_authentication_exists_from_geoloc_before_mintime bool +has_deprecated_authentication_exists_from_geoloc_before_mintime bool +deprecated_machine_id u64 +has_deprecated_machine_id bool +session_data []CCredentialsGetSteamGuardDetailsResponseSessionData +is_twofactor_enabled bool +has_is_twofactor_enabled bool +timestamp_twofactor_enabled u32 +has_timestamp_twofactor_enabled bool +is_phone_verified bool +has_is_phone_verified bool +} +pub fn (o &CCredentialsGetSteamGuardDetailsResponse) pack() []byte { +mut res := []byte{} +if o.has_is_steamguard_enabled { +res << vproto.pack_bool_field(o.is_steamguard_enabled, 1) +} + +if o.has_timestamp_steamguard_enabled { +res << vproto.pack_32bit_field(o.timestamp_steamguard_enabled, 2) +} + +// [packed=false] +for _, x in o.deprecated_newauthentication { +res << zzz_vproto_internal_pack_ccredentialsgetsteamguarddetailsresponsenewauthentication(x, 3) +} + +if o.has_deprecated_machine_name_userchosen { +res << vproto.pack_string_field(o.deprecated_machine_name_userchosen, 4) +} + +if o.has_deprecated_timestamp_machine_steamguard_enabled { +res << vproto.pack_32bit_field(o.deprecated_timestamp_machine_steamguard_enabled, 5) +} + +if o.has_deprecated_authentication_exists_from_geoloc_before_mintime { +res << vproto.pack_bool_field(o.deprecated_authentication_exists_from_geoloc_before_mintime, 6) +} + +if o.has_deprecated_machine_id { +res << vproto.pack_uint64_field(o.deprecated_machine_id, 7) +} + +// [packed=false] +for _, x in o.session_data { +res << zzz_vproto_internal_pack_ccredentialsgetsteamguarddetailsresponsesessiondata(x, 8) +} + +if o.has_is_twofactor_enabled { +res << vproto.pack_bool_field(o.is_twofactor_enabled, 9) +} + +if o.has_timestamp_twofactor_enabled { +res << vproto.pack_32bit_field(o.timestamp_twofactor_enabled, 10) +} + +if o.has_is_phone_verified { +res << vproto.pack_bool_field(o.is_phone_verified, 11) +} + +return res +} + +pub fn ccredentialsgetsteamguarddetailsresponse_unpack(buf []byte) ?CCredentialsGetSteamGuardDetailsResponse { +mut res := CCredentialsGetSteamGuardDetailsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_is_steamguard_enabled = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_steamguard_enabled = v +i = ii +} + +2 { +res.has_timestamp_steamguard_enabled = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp_steamguard_enabled = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_ccredentialsgetsteamguarddetailsresponsenewauthentication(cur_buf, tag_wiretype.wire_type)? +res.deprecated_newauthentication << v +i = ii +} + +4 { +res.has_deprecated_machine_name_userchosen = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated_machine_name_userchosen = v +i = ii +} + +5 { +res.has_deprecated_timestamp_machine_steamguard_enabled = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated_timestamp_machine_steamguard_enabled = v +i = ii +} + +6 { +res.has_deprecated_authentication_exists_from_geoloc_before_mintime = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated_authentication_exists_from_geoloc_before_mintime = v +i = ii +} + +7 { +res.has_deprecated_machine_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.deprecated_machine_id = v +i = ii +} + +8 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_ccredentialsgetsteamguarddetailsresponsesessiondata(cur_buf, tag_wiretype.wire_type)? +res.session_data << v +i = ii +} + +9 { +res.has_is_twofactor_enabled = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_twofactor_enabled = v +i = ii +} + +10 { +res.has_timestamp_twofactor_enabled = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp_twofactor_enabled = v +i = ii +} + +11 { +res.has_is_phone_verified = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_phone_verified = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccredentialsgetsteamguarddetailsresponse() CCredentialsGetSteamGuardDetailsResponse { +return CCredentialsGetSteamGuardDetailsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccredentialsgetsteamguarddetailsresponse(o CCredentialsGetSteamGuardDetailsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccredentialsgetsteamguarddetailsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CCredentialsGetSteamGuardDetailsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccredentialsgetsteamguarddetailsresponse_unpack(v)? +return i, unpacked +} +pub struct CCredentialsNewMachineNotificationDialogRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +is_approved bool +has_is_approved bool +is_wizard_complete bool +has_is_wizard_complete bool +} +pub fn (o &CCredentialsNewMachineNotificationDialogRequest) pack() []byte { +mut res := []byte{} +if o.has_is_approved { +res << vproto.pack_bool_field(o.is_approved, 1) +} + +if o.has_is_wizard_complete { +res << vproto.pack_bool_field(o.is_wizard_complete, 2) +} + +return res +} + +pub fn ccredentialsnewmachinenotificationdialogrequest_unpack(buf []byte) ?CCredentialsNewMachineNotificationDialogRequest { +mut res := CCredentialsNewMachineNotificationDialogRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_is_approved = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_approved = v +i = ii +} + +2 { +res.has_is_wizard_complete = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_wizard_complete = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccredentialsnewmachinenotificationdialogrequest() CCredentialsNewMachineNotificationDialogRequest { +return CCredentialsNewMachineNotificationDialogRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccredentialsnewmachinenotificationdialogrequest(o CCredentialsNewMachineNotificationDialogRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccredentialsnewmachinenotificationdialogrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CCredentialsNewMachineNotificationDialogRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccredentialsnewmachinenotificationdialogrequest_unpack(v)? +return i, unpacked +} +pub struct CCredentialsNewMachineNotificationDialogResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CCredentialsNewMachineNotificationDialogResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn ccredentialsnewmachinenotificationdialogresponse_unpack(buf []byte) ?CCredentialsNewMachineNotificationDialogResponse { +res := CCredentialsNewMachineNotificationDialogResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccredentialsnewmachinenotificationdialogresponse() CCredentialsNewMachineNotificationDialogResponse { +return CCredentialsNewMachineNotificationDialogResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccredentialsnewmachinenotificationdialogresponse(o CCredentialsNewMachineNotificationDialogResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccredentialsnewmachinenotificationdialogresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CCredentialsNewMachineNotificationDialogResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccredentialsnewmachinenotificationdialogresponse_unpack(v)? +return i, unpacked +} +pub struct CCredentialsValidateEmailAddressRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +stoken string +has_stoken bool +} +pub fn (o &CCredentialsValidateEmailAddressRequest) pack() []byte { +mut res := []byte{} +if o.has_stoken { +res << vproto.pack_string_field(o.stoken, 1) +} + +return res +} + +pub fn ccredentialsvalidateemailaddressrequest_unpack(buf []byte) ?CCredentialsValidateEmailAddressRequest { +mut res := CCredentialsValidateEmailAddressRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_stoken = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.stoken = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccredentialsvalidateemailaddressrequest() CCredentialsValidateEmailAddressRequest { +return CCredentialsValidateEmailAddressRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccredentialsvalidateemailaddressrequest(o CCredentialsValidateEmailAddressRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccredentialsvalidateemailaddressrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CCredentialsValidateEmailAddressRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccredentialsvalidateemailaddressrequest_unpack(v)? +return i, unpacked +} +pub struct CCredentialsValidateEmailAddressResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +was_validated bool +has_was_validated bool +} +pub fn (o &CCredentialsValidateEmailAddressResponse) pack() []byte { +mut res := []byte{} +if o.has_was_validated { +res << vproto.pack_bool_field(o.was_validated, 1) +} + +return res +} + +pub fn ccredentialsvalidateemailaddressresponse_unpack(buf []byte) ?CCredentialsValidateEmailAddressResponse { +mut res := CCredentialsValidateEmailAddressResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_was_validated = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.was_validated = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccredentialsvalidateemailaddressresponse() CCredentialsValidateEmailAddressResponse { +return CCredentialsValidateEmailAddressResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccredentialsvalidateemailaddressresponse(o CCredentialsValidateEmailAddressResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccredentialsvalidateemailaddressresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CCredentialsValidateEmailAddressResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccredentialsvalidateemailaddressresponse_unpack(v)? +return i, unpacked +} +pub struct CCredentialsSteamGuardPhishingReportRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +param_string string +has_param_string bool +ipaddress_actual u32 +has_ipaddress_actual bool +} +pub fn (o &CCredentialsSteamGuardPhishingReportRequest) pack() []byte { +mut res := []byte{} +if o.has_param_string { +res << vproto.pack_string_field(o.param_string, 1) +} + +if o.has_ipaddress_actual { +res << vproto.pack_uint32_field(o.ipaddress_actual, 2) +} + +return res +} + +pub fn ccredentialssteamguardphishingreportrequest_unpack(buf []byte) ?CCredentialsSteamGuardPhishingReportRequest { +mut res := CCredentialsSteamGuardPhishingReportRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_param_string = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.param_string = v +i = ii +} + +2 { +res.has_ipaddress_actual = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ipaddress_actual = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccredentialssteamguardphishingreportrequest() CCredentialsSteamGuardPhishingReportRequest { +return CCredentialsSteamGuardPhishingReportRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccredentialssteamguardphishingreportrequest(o CCredentialsSteamGuardPhishingReportRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccredentialssteamguardphishingreportrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CCredentialsSteamGuardPhishingReportRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccredentialssteamguardphishingreportrequest_unpack(v)? +return i, unpacked +} +pub struct CCredentialsSteamGuardPhishingReportResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +ipaddress_loginattempt u32 +has_ipaddress_loginattempt bool +countryname_loginattempt string +has_countryname_loginattempt bool +statename_loginattempt string +has_statename_loginattempt bool +cityname_loginattempt string +has_cityname_loginattempt bool +ipaddress_actual u32 +has_ipaddress_actual bool +countryname_actual string +has_countryname_actual bool +statename_actual string +has_statename_actual bool +cityname_actual string +has_cityname_actual bool +steamguard_code string +has_steamguard_code bool +} +pub fn (o &CCredentialsSteamGuardPhishingReportResponse) pack() []byte { +mut res := []byte{} +if o.has_ipaddress_loginattempt { +res << vproto.pack_uint32_field(o.ipaddress_loginattempt, 1) +} + +if o.has_countryname_loginattempt { +res << vproto.pack_string_field(o.countryname_loginattempt, 2) +} + +if o.has_statename_loginattempt { +res << vproto.pack_string_field(o.statename_loginattempt, 3) +} + +if o.has_cityname_loginattempt { +res << vproto.pack_string_field(o.cityname_loginattempt, 4) +} + +if o.has_ipaddress_actual { +res << vproto.pack_uint32_field(o.ipaddress_actual, 5) +} + +if o.has_countryname_actual { +res << vproto.pack_string_field(o.countryname_actual, 6) +} + +if o.has_statename_actual { +res << vproto.pack_string_field(o.statename_actual, 7) +} + +if o.has_cityname_actual { +res << vproto.pack_string_field(o.cityname_actual, 8) +} + +if o.has_steamguard_code { +res << vproto.pack_string_field(o.steamguard_code, 9) +} + +return res +} + +pub fn ccredentialssteamguardphishingreportresponse_unpack(buf []byte) ?CCredentialsSteamGuardPhishingReportResponse { +mut res := CCredentialsSteamGuardPhishingReportResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_ipaddress_loginattempt = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ipaddress_loginattempt = v +i = ii +} + +2 { +res.has_countryname_loginattempt = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.countryname_loginattempt = v +i = ii +} + +3 { +res.has_statename_loginattempt = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.statename_loginattempt = v +i = ii +} + +4 { +res.has_cityname_loginattempt = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.cityname_loginattempt = v +i = ii +} + +5 { +res.has_ipaddress_actual = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ipaddress_actual = v +i = ii +} + +6 { +res.has_countryname_actual = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.countryname_actual = v +i = ii +} + +7 { +res.has_statename_actual = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.statename_actual = v +i = ii +} + +8 { +res.has_cityname_actual = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.cityname_actual = v +i = ii +} + +9 { +res.has_steamguard_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.steamguard_code = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccredentialssteamguardphishingreportresponse() CCredentialsSteamGuardPhishingReportResponse { +return CCredentialsSteamGuardPhishingReportResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccredentialssteamguardphishingreportresponse(o CCredentialsSteamGuardPhishingReportResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccredentialssteamguardphishingreportresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CCredentialsSteamGuardPhishingReportResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccredentialssteamguardphishingreportresponse_unpack(v)? +return i, unpacked +} +pub struct CCredentialsLastCredentialChangeTimeRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +user_changes_only bool +has_user_changes_only bool +} +pub fn (o &CCredentialsLastCredentialChangeTimeRequest) pack() []byte { +mut res := []byte{} +if o.has_user_changes_only { +res << vproto.pack_bool_field(o.user_changes_only, 1) +} + +return res +} + +pub fn ccredentialslastcredentialchangetimerequest_unpack(buf []byte) ?CCredentialsLastCredentialChangeTimeRequest { +mut res := CCredentialsLastCredentialChangeTimeRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_user_changes_only = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.user_changes_only = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccredentialslastcredentialchangetimerequest() CCredentialsLastCredentialChangeTimeRequest { +return CCredentialsLastCredentialChangeTimeRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccredentialslastcredentialchangetimerequest(o CCredentialsLastCredentialChangeTimeRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccredentialslastcredentialchangetimerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CCredentialsLastCredentialChangeTimeRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccredentialslastcredentialchangetimerequest_unpack(v)? +return i, unpacked +} +pub struct CCredentialsLastCredentialChangeTimeResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +timestamp_last_password_change u32 +has_timestamp_last_password_change bool +timestamp_last_email_change u32 +has_timestamp_last_email_change bool +timestamp_last_password_reset u32 +has_timestamp_last_password_reset bool +} +pub fn (o &CCredentialsLastCredentialChangeTimeResponse) pack() []byte { +mut res := []byte{} +if o.has_timestamp_last_password_change { +res << vproto.pack_32bit_field(o.timestamp_last_password_change, 1) +} + +if o.has_timestamp_last_email_change { +res << vproto.pack_32bit_field(o.timestamp_last_email_change, 2) +} + +if o.has_timestamp_last_password_reset { +res << vproto.pack_32bit_field(o.timestamp_last_password_reset, 3) +} + +return res +} + +pub fn ccredentialslastcredentialchangetimeresponse_unpack(buf []byte) ?CCredentialsLastCredentialChangeTimeResponse { +mut res := CCredentialsLastCredentialChangeTimeResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_timestamp_last_password_change = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp_last_password_change = v +i = ii +} + +2 { +res.has_timestamp_last_email_change = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp_last_email_change = v +i = ii +} + +3 { +res.has_timestamp_last_password_reset = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp_last_password_reset = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccredentialslastcredentialchangetimeresponse() CCredentialsLastCredentialChangeTimeResponse { +return CCredentialsLastCredentialChangeTimeResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccredentialslastcredentialchangetimeresponse(o CCredentialsLastCredentialChangeTimeResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccredentialslastcredentialchangetimeresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CCredentialsLastCredentialChangeTimeResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccredentialslastcredentialchangetimeresponse_unpack(v)? +return i, unpacked +} +pub struct CCredentialsGetAccountAuthSecretRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CCredentialsGetAccountAuthSecretRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn ccredentialsgetaccountauthsecretrequest_unpack(buf []byte) ?CCredentialsGetAccountAuthSecretRequest { +res := CCredentialsGetAccountAuthSecretRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccredentialsgetaccountauthsecretrequest() CCredentialsGetAccountAuthSecretRequest { +return CCredentialsGetAccountAuthSecretRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccredentialsgetaccountauthsecretrequest(o CCredentialsGetAccountAuthSecretRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccredentialsgetaccountauthsecretrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CCredentialsGetAccountAuthSecretRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccredentialsgetaccountauthsecretrequest_unpack(v)? +return i, unpacked +} +pub struct CCredentialsGetAccountAuthSecretResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +secret_id int +has_secret_id bool +secret []byte +has_secret bool +} +pub fn (o &CCredentialsGetAccountAuthSecretResponse) pack() []byte { +mut res := []byte{} +if o.has_secret_id { +res << vproto.pack_int32_field(o.secret_id, 1) +} + +if o.has_secret { +res << vproto.pack_bytes_field(o.secret, 2) +} + +return res +} + +pub fn ccredentialsgetaccountauthsecretresponse_unpack(buf []byte) ?CCredentialsGetAccountAuthSecretResponse { +mut res := CCredentialsGetAccountAuthSecretResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_secret_id = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.secret_id = v +i = ii +} + +2 { +res.has_secret = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.secret = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccredentialsgetaccountauthsecretresponse() CCredentialsGetAccountAuthSecretResponse { +return CCredentialsGetAccountAuthSecretResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccredentialsgetaccountauthsecretresponse(o CCredentialsGetAccountAuthSecretResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccredentialsgetaccountauthsecretresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CCredentialsGetAccountAuthSecretResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccredentialsgetaccountauthsecretresponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_datapublisher.steamclient_pb.v b/proto/steammessages_datapublisher.steamclient_pb.v new file mode 100644 index 0000000..4dd9270 --- /dev/null +++ b/proto/steammessages_datapublisher.steamclient_pb.v @@ -0,0 +1,324 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CDataPublisherClientContentCorruptionReportNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +depotid u32 +has_depotid bool +download_source string +has_download_source bool +objectid string +has_objectid bool +cellid u32 +has_cellid bool +is_manifest bool +has_is_manifest bool +object_size u64 +has_object_size bool +corruption_type u32 +has_corruption_type bool +used_https bool +has_used_https bool +oc_proxy_detected bool +has_oc_proxy_detected bool +} +pub fn (o &CDataPublisherClientContentCorruptionReportNotification) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_depotid { +res << vproto.pack_uint32_field(o.depotid, 2) +} + +if o.has_download_source { +res << vproto.pack_string_field(o.download_source, 3) +} + +if o.has_objectid { +res << vproto.pack_string_field(o.objectid, 4) +} + +if o.has_cellid { +res << vproto.pack_uint32_field(o.cellid, 5) +} + +if o.has_is_manifest { +res << vproto.pack_bool_field(o.is_manifest, 6) +} + +if o.has_object_size { +res << vproto.pack_uint64_field(o.object_size, 7) +} + +if o.has_corruption_type { +res << vproto.pack_uint32_field(o.corruption_type, 8) +} + +if o.has_used_https { +res << vproto.pack_bool_field(o.used_https, 9) +} + +if o.has_oc_proxy_detected { +res << vproto.pack_bool_field(o.oc_proxy_detected, 10) +} + +return res +} + +pub fn cdatapublisherclientcontentcorruptionreportnotification_unpack(buf []byte) ?CDataPublisherClientContentCorruptionReportNotification { +mut res := CDataPublisherClientContentCorruptionReportNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_depotid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.depotid = v +i = ii +} + +3 { +res.has_download_source = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.download_source = v +i = ii +} + +4 { +res.has_objectid = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.objectid = v +i = ii +} + +5 { +res.has_cellid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cellid = v +i = ii +} + +6 { +res.has_is_manifest = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_manifest = v +i = ii +} + +7 { +res.has_object_size = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.object_size = v +i = ii +} + +8 { +res.has_corruption_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.corruption_type = v +i = ii +} + +9 { +res.has_used_https = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.used_https = v +i = ii +} + +10 { +res.has_oc_proxy_detected = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.oc_proxy_detected = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdatapublisherclientcontentcorruptionreportnotification() CDataPublisherClientContentCorruptionReportNotification { +return CDataPublisherClientContentCorruptionReportNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdatapublisherclientcontentcorruptionreportnotification(o CDataPublisherClientContentCorruptionReportNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdatapublisherclientcontentcorruptionreportnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CDataPublisherClientContentCorruptionReportNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdatapublisherclientcontentcorruptionreportnotification_unpack(v)? +return i, unpacked +} +pub struct CValveHWsurveyGetSurveyScheduleRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +surveydatetoken string +has_surveydatetoken bool +surveydatetokenversion u64 +has_surveydatetokenversion bool +} +pub fn (o &CValveHWsurveyGetSurveyScheduleRequest) pack() []byte { +mut res := []byte{} +if o.has_surveydatetoken { +res << vproto.pack_string_field(o.surveydatetoken, 1) +} + +if o.has_surveydatetokenversion { +res << vproto.pack_64bit_field(o.surveydatetokenversion, 2) +} + +return res +} + +pub fn cvalvehwsurveygetsurveyschedulerequest_unpack(buf []byte) ?CValveHWsurveyGetSurveyScheduleRequest { +mut res := CValveHWsurveyGetSurveyScheduleRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_surveydatetoken = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.surveydatetoken = v +i = ii +} + +2 { +res.has_surveydatetokenversion = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.surveydatetokenversion = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cvalvehwsurveygetsurveyschedulerequest() CValveHWsurveyGetSurveyScheduleRequest { +return CValveHWsurveyGetSurveyScheduleRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cvalvehwsurveygetsurveyschedulerequest(o CValveHWsurveyGetSurveyScheduleRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cvalvehwsurveygetsurveyschedulerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CValveHWsurveyGetSurveyScheduleRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cvalvehwsurveygetsurveyschedulerequest_unpack(v)? +return i, unpacked +} +pub struct CValveHWsurveyGetSurveyScheduleResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +surveydatetoken u32 +has_surveydatetoken bool +surveydatetokenversion u64 +has_surveydatetokenversion bool +} +pub fn (o &CValveHWsurveyGetSurveyScheduleResponse) pack() []byte { +mut res := []byte{} +if o.has_surveydatetoken { +res << vproto.pack_uint32_field(o.surveydatetoken, 1) +} + +if o.has_surveydatetokenversion { +res << vproto.pack_64bit_field(o.surveydatetokenversion, 2) +} + +return res +} + +pub fn cvalvehwsurveygetsurveyscheduleresponse_unpack(buf []byte) ?CValveHWsurveyGetSurveyScheduleResponse { +mut res := CValveHWsurveyGetSurveyScheduleResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_surveydatetoken = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.surveydatetoken = v +i = ii +} + +2 { +res.has_surveydatetokenversion = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.surveydatetokenversion = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cvalvehwsurveygetsurveyscheduleresponse() CValveHWsurveyGetSurveyScheduleResponse { +return CValveHWsurveyGetSurveyScheduleResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cvalvehwsurveygetsurveyscheduleresponse(o CValveHWsurveyGetSurveyScheduleResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cvalvehwsurveygetsurveyscheduleresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CValveHWsurveyGetSurveyScheduleResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cvalvehwsurveygetsurveyscheduleresponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_depotbuilder.steamclient_pb.v b/proto/steammessages_depotbuilder.steamclient_pb.v new file mode 100644 index 0000000..d24b3bf --- /dev/null +++ b/proto/steammessages_depotbuilder.steamclient_pb.v @@ -0,0 +1,1196 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CContentBuilderInitDepotBuildRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +depotid u32 +has_depotid bool +workshop_itemid u64 +has_workshop_itemid bool +for_local_cs bool +has_for_local_cs bool +} +pub fn (o &CContentBuilderInitDepotBuildRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_depotid { +res << vproto.pack_uint32_field(o.depotid, 2) +} + +if o.has_workshop_itemid { +res << vproto.pack_uint64_field(o.workshop_itemid, 3) +} + +if o.has_for_local_cs { +res << vproto.pack_bool_field(o.for_local_cs, 4) +} + +return res +} + +pub fn ccontentbuilderinitdepotbuildrequest_unpack(buf []byte) ?CContentBuilderInitDepotBuildRequest { +mut res := CContentBuilderInitDepotBuildRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_depotid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.depotid = v +i = ii +} + +3 { +res.has_workshop_itemid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.workshop_itemid = v +i = ii +} + +4 { +res.has_for_local_cs = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.for_local_cs = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccontentbuilderinitdepotbuildrequest() CContentBuilderInitDepotBuildRequest { +return CContentBuilderInitDepotBuildRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccontentbuilderinitdepotbuildrequest(o CContentBuilderInitDepotBuildRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccontentbuilderinitdepotbuildrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CContentBuilderInitDepotBuildRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccontentbuilderinitdepotbuildrequest_unpack(v)? +return i, unpacked +} +pub struct CContentBuilderInitDepotBuildResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +baseline_manifestid u64 +has_baseline_manifestid bool +chunk_size u32 +has_chunk_size bool +aes_key []byte +has_aes_key bool +rsa_key []byte +has_rsa_key bool +url_host string +has_url_host bool +offset_detection_enabled bool +has_offset_detection_enabled bool +offset_detection_min_clean_chunk u32 +has_offset_detection_min_clean_chunk bool +offset_detection_blast_radius_pre u32 +has_offset_detection_blast_radius_pre bool +offset_detection_blast_radius_post u32 +has_offset_detection_blast_radius_post bool +offset_detection_max_distance_pre u32 +has_offset_detection_max_distance_pre bool +offset_detection_max_distance_post u32 +has_offset_detection_max_distance_post bool +} +pub fn (o &CContentBuilderInitDepotBuildResponse) pack() []byte { +mut res := []byte{} +if o.has_baseline_manifestid { +res << vproto.pack_uint64_field(o.baseline_manifestid, 1) +} + +if o.has_chunk_size { +res << vproto.pack_uint32_field(o.chunk_size, 2) +} + +if o.has_aes_key { +res << vproto.pack_bytes_field(o.aes_key, 3) +} + +if o.has_rsa_key { +res << vproto.pack_bytes_field(o.rsa_key, 4) +} + +if o.has_url_host { +res << vproto.pack_string_field(o.url_host, 5) +} + +if o.has_offset_detection_enabled { +res << vproto.pack_bool_field(o.offset_detection_enabled, 6) +} + +if o.has_offset_detection_min_clean_chunk { +res << vproto.pack_uint32_field(o.offset_detection_min_clean_chunk, 7) +} + +if o.has_offset_detection_blast_radius_pre { +res << vproto.pack_uint32_field(o.offset_detection_blast_radius_pre, 8) +} + +if o.has_offset_detection_blast_radius_post { +res << vproto.pack_uint32_field(o.offset_detection_blast_radius_post, 9) +} + +if o.has_offset_detection_max_distance_pre { +res << vproto.pack_uint32_field(o.offset_detection_max_distance_pre, 10) +} + +if o.has_offset_detection_max_distance_post { +res << vproto.pack_uint32_field(o.offset_detection_max_distance_post, 11) +} + +return res +} + +pub fn ccontentbuilderinitdepotbuildresponse_unpack(buf []byte) ?CContentBuilderInitDepotBuildResponse { +mut res := CContentBuilderInitDepotBuildResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_baseline_manifestid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.baseline_manifestid = v +i = ii +} + +2 { +res.has_chunk_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.chunk_size = v +i = ii +} + +3 { +res.has_aes_key = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.aes_key = v +i = ii +} + +4 { +res.has_rsa_key = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.rsa_key = v +i = ii +} + +5 { +res.has_url_host = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url_host = v +i = ii +} + +6 { +res.has_offset_detection_enabled = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.offset_detection_enabled = v +i = ii +} + +7 { +res.has_offset_detection_min_clean_chunk = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.offset_detection_min_clean_chunk = v +i = ii +} + +8 { +res.has_offset_detection_blast_radius_pre = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.offset_detection_blast_radius_pre = v +i = ii +} + +9 { +res.has_offset_detection_blast_radius_post = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.offset_detection_blast_radius_post = v +i = ii +} + +10 { +res.has_offset_detection_max_distance_pre = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.offset_detection_max_distance_pre = v +i = ii +} + +11 { +res.has_offset_detection_max_distance_post = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.offset_detection_max_distance_post = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccontentbuilderinitdepotbuildresponse() CContentBuilderInitDepotBuildResponse { +return CContentBuilderInitDepotBuildResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccontentbuilderinitdepotbuildresponse(o CContentBuilderInitDepotBuildResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccontentbuilderinitdepotbuildresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CContentBuilderInitDepotBuildResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccontentbuilderinitdepotbuildresponse_unpack(v)? +return i, unpacked +} +pub struct CContentBuilderStartDepotUploadRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +depotid u32 +has_depotid bool +workshop_itemid u64 +has_workshop_itemid bool +for_local_cs bool +has_for_local_cs bool +baseline_manifestid u64 +has_baseline_manifestid bool +manifest_size u32 +has_manifest_size bool +} +pub fn (o &CContentBuilderStartDepotUploadRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_depotid { +res << vproto.pack_uint32_field(o.depotid, 2) +} + +if o.has_workshop_itemid { +res << vproto.pack_uint64_field(o.workshop_itemid, 3) +} + +if o.has_for_local_cs { +res << vproto.pack_bool_field(o.for_local_cs, 4) +} + +if o.has_baseline_manifestid { +res << vproto.pack_uint64_field(o.baseline_manifestid, 5) +} + +if o.has_manifest_size { +res << vproto.pack_uint32_field(o.manifest_size, 6) +} + +return res +} + +pub fn ccontentbuilderstartdepotuploadrequest_unpack(buf []byte) ?CContentBuilderStartDepotUploadRequest { +mut res := CContentBuilderStartDepotUploadRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_depotid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.depotid = v +i = ii +} + +3 { +res.has_workshop_itemid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.workshop_itemid = v +i = ii +} + +4 { +res.has_for_local_cs = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.for_local_cs = v +i = ii +} + +5 { +res.has_baseline_manifestid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.baseline_manifestid = v +i = ii +} + +6 { +res.has_manifest_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.manifest_size = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccontentbuilderstartdepotuploadrequest() CContentBuilderStartDepotUploadRequest { +return CContentBuilderStartDepotUploadRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccontentbuilderstartdepotuploadrequest(o CContentBuilderStartDepotUploadRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccontentbuilderstartdepotuploadrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CContentBuilderStartDepotUploadRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccontentbuilderstartdepotuploadrequest_unpack(v)? +return i, unpacked +} +pub struct CContentBuilderStartDepotUploadResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +depot_build_handle u64 +has_depot_build_handle bool +} +pub fn (o &CContentBuilderStartDepotUploadResponse) pack() []byte { +mut res := []byte{} +if o.has_depot_build_handle { +res << vproto.pack_uint64_field(o.depot_build_handle, 1) +} + +return res +} + +pub fn ccontentbuilderstartdepotuploadresponse_unpack(buf []byte) ?CContentBuilderStartDepotUploadResponse { +mut res := CContentBuilderStartDepotUploadResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_depot_build_handle = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.depot_build_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccontentbuilderstartdepotuploadresponse() CContentBuilderStartDepotUploadResponse { +return CContentBuilderStartDepotUploadResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccontentbuilderstartdepotuploadresponse(o CContentBuilderStartDepotUploadResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccontentbuilderstartdepotuploadresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CContentBuilderStartDepotUploadResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccontentbuilderstartdepotuploadresponse_unpack(v)? +return i, unpacked +} +pub struct CContentBuilderGetMissingDepotChunksRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +depot_build_handle u64 +has_depot_build_handle bool +} +pub fn (o &CContentBuilderGetMissingDepotChunksRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_depot_build_handle { +res << vproto.pack_uint64_field(o.depot_build_handle, 2) +} + +return res +} + +pub fn ccontentbuildergetmissingdepotchunksrequest_unpack(buf []byte) ?CContentBuilderGetMissingDepotChunksRequest { +mut res := CContentBuilderGetMissingDepotChunksRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_depot_build_handle = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.depot_build_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccontentbuildergetmissingdepotchunksrequest() CContentBuilderGetMissingDepotChunksRequest { +return CContentBuilderGetMissingDepotChunksRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccontentbuildergetmissingdepotchunksrequest(o CContentBuilderGetMissingDepotChunksRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccontentbuildergetmissingdepotchunksrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CContentBuilderGetMissingDepotChunksRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccontentbuildergetmissingdepotchunksrequest_unpack(v)? +return i, unpacked +} +pub struct CContentBuilderGetMissingDepotChunksResponseChunks { +mut: +unknown_fields []vproto.UnknownField +pub mut: +sha []byte +has_sha bool +} +pub fn (o &CContentBuilderGetMissingDepotChunksResponseChunks) pack() []byte { +mut res := []byte{} +if o.has_sha { +res << vproto.pack_bytes_field(o.sha, 1) +} + +return res +} + +pub fn ccontentbuildergetmissingdepotchunksresponsechunks_unpack(buf []byte) ?CContentBuilderGetMissingDepotChunksResponseChunks { +mut res := CContentBuilderGetMissingDepotChunksResponseChunks{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_sha = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccontentbuildergetmissingdepotchunksresponsechunks() CContentBuilderGetMissingDepotChunksResponseChunks { +return CContentBuilderGetMissingDepotChunksResponseChunks{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccontentbuildergetmissingdepotchunksresponsechunks(o CContentBuilderGetMissingDepotChunksResponseChunks, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccontentbuildergetmissingdepotchunksresponsechunks(buf []byte, tag_wiretype vproto.WireType) ?(int, CContentBuilderGetMissingDepotChunksResponseChunks) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccontentbuildergetmissingdepotchunksresponsechunks_unpack(v)? +return i, unpacked +} +pub struct CContentBuilderGetMissingDepotChunksResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +missing_chunks []CContentBuilderGetMissingDepotChunksResponseChunks +total_missing_chunks u32 +has_total_missing_chunks bool +total_missing_bytes u64 +has_total_missing_bytes bool +} +pub fn (o &CContentBuilderGetMissingDepotChunksResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.missing_chunks { +res << zzz_vproto_internal_pack_ccontentbuildergetmissingdepotchunksresponsechunks(x, 1) +} + +if o.has_total_missing_chunks { +res << vproto.pack_uint32_field(o.total_missing_chunks, 2) +} + +if o.has_total_missing_bytes { +res << vproto.pack_uint64_field(o.total_missing_bytes, 3) +} + +return res +} + +pub fn ccontentbuildergetmissingdepotchunksresponse_unpack(buf []byte) ?CContentBuilderGetMissingDepotChunksResponse { +mut res := CContentBuilderGetMissingDepotChunksResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_ccontentbuildergetmissingdepotchunksresponsechunks(cur_buf, tag_wiretype.wire_type)? +res.missing_chunks << v +i = ii +} + +2 { +res.has_total_missing_chunks = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.total_missing_chunks = v +i = ii +} + +3 { +res.has_total_missing_bytes = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.total_missing_bytes = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccontentbuildergetmissingdepotchunksresponse() CContentBuilderGetMissingDepotChunksResponse { +return CContentBuilderGetMissingDepotChunksResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccontentbuildergetmissingdepotchunksresponse(o CContentBuilderGetMissingDepotChunksResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccontentbuildergetmissingdepotchunksresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CContentBuilderGetMissingDepotChunksResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccontentbuildergetmissingdepotchunksresponse_unpack(v)? +return i, unpacked +} +pub struct CContentBuilderFinishDepotUploadRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +depot_build_handle u64 +has_depot_build_handle bool +} +pub fn (o &CContentBuilderFinishDepotUploadRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_depot_build_handle { +res << vproto.pack_uint64_field(o.depot_build_handle, 2) +} + +return res +} + +pub fn ccontentbuilderfinishdepotuploadrequest_unpack(buf []byte) ?CContentBuilderFinishDepotUploadRequest { +mut res := CContentBuilderFinishDepotUploadRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_depot_build_handle = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.depot_build_handle = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccontentbuilderfinishdepotuploadrequest() CContentBuilderFinishDepotUploadRequest { +return CContentBuilderFinishDepotUploadRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccontentbuilderfinishdepotuploadrequest(o CContentBuilderFinishDepotUploadRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccontentbuilderfinishdepotuploadrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CContentBuilderFinishDepotUploadRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccontentbuilderfinishdepotuploadrequest_unpack(v)? +return i, unpacked +} +pub struct CContentBuilderFinishDepotUploadResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +manifestid u64 +has_manifestid bool +prev_reused bool +has_prev_reused bool +} +pub fn (o &CContentBuilderFinishDepotUploadResponse) pack() []byte { +mut res := []byte{} +if o.has_manifestid { +res << vproto.pack_uint64_field(o.manifestid, 1) +} + +if o.has_prev_reused { +res << vproto.pack_bool_field(o.prev_reused, 2) +} + +return res +} + +pub fn ccontentbuilderfinishdepotuploadresponse_unpack(buf []byte) ?CContentBuilderFinishDepotUploadResponse { +mut res := CContentBuilderFinishDepotUploadResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_manifestid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.manifestid = v +i = ii +} + +2 { +res.has_prev_reused = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.prev_reused = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccontentbuilderfinishdepotuploadresponse() CContentBuilderFinishDepotUploadResponse { +return CContentBuilderFinishDepotUploadResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccontentbuilderfinishdepotuploadresponse(o CContentBuilderFinishDepotUploadResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccontentbuilderfinishdepotuploadresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CContentBuilderFinishDepotUploadResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccontentbuilderfinishdepotuploadresponse_unpack(v)? +return i, unpacked +} +pub struct CContentBuilderCommitAppBuildRequestDepots { +mut: +unknown_fields []vproto.UnknownField +pub mut: +depotid u32 +has_depotid bool +manifestid u64 +has_manifestid bool +} +pub fn (o &CContentBuilderCommitAppBuildRequestDepots) pack() []byte { +mut res := []byte{} +if o.has_depotid { +res << vproto.pack_uint32_field(o.depotid, 1) +} + +if o.has_manifestid { +res << vproto.pack_uint64_field(o.manifestid, 2) +} + +return res +} + +pub fn ccontentbuildercommitappbuildrequestdepots_unpack(buf []byte) ?CContentBuilderCommitAppBuildRequestDepots { +mut res := CContentBuilderCommitAppBuildRequestDepots{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_depotid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.depotid = v +i = ii +} + +2 { +res.has_manifestid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.manifestid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccontentbuildercommitappbuildrequestdepots() CContentBuilderCommitAppBuildRequestDepots { +return CContentBuilderCommitAppBuildRequestDepots{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccontentbuildercommitappbuildrequestdepots(o CContentBuilderCommitAppBuildRequestDepots, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccontentbuildercommitappbuildrequestdepots(buf []byte, tag_wiretype vproto.WireType) ?(int, CContentBuilderCommitAppBuildRequestDepots) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccontentbuildercommitappbuildrequestdepots_unpack(v)? +return i, unpacked +} +pub struct CContentBuilderCommitAppBuildRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +depot_manifests []CContentBuilderCommitAppBuildRequestDepots +build_notes string +has_build_notes bool +live_branch string +has_live_branch bool +} +pub fn (o &CContentBuilderCommitAppBuildRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +// [packed=false] +for _, x in o.depot_manifests { +res << zzz_vproto_internal_pack_ccontentbuildercommitappbuildrequestdepots(x, 2) +} + +if o.has_build_notes { +res << vproto.pack_string_field(o.build_notes, 4) +} + +if o.has_live_branch { +res << vproto.pack_string_field(o.live_branch, 5) +} + +return res +} + +pub fn ccontentbuildercommitappbuildrequest_unpack(buf []byte) ?CContentBuilderCommitAppBuildRequest { +mut res := CContentBuilderCommitAppBuildRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_ccontentbuildercommitappbuildrequestdepots(cur_buf, tag_wiretype.wire_type)? +res.depot_manifests << v +i = ii +} + +4 { +res.has_build_notes = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.build_notes = v +i = ii +} + +5 { +res.has_live_branch = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.live_branch = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccontentbuildercommitappbuildrequest() CContentBuilderCommitAppBuildRequest { +return CContentBuilderCommitAppBuildRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccontentbuildercommitappbuildrequest(o CContentBuilderCommitAppBuildRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccontentbuildercommitappbuildrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CContentBuilderCommitAppBuildRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccontentbuildercommitappbuildrequest_unpack(v)? +return i, unpacked +} +pub struct CContentBuilderCommitAppBuildResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +buildid u32 +has_buildid bool +} +pub fn (o &CContentBuilderCommitAppBuildResponse) pack() []byte { +mut res := []byte{} +if o.has_buildid { +res << vproto.pack_uint32_field(o.buildid, 1) +} + +return res +} + +pub fn ccontentbuildercommitappbuildresponse_unpack(buf []byte) ?CContentBuilderCommitAppBuildResponse { +mut res := CContentBuilderCommitAppBuildResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_buildid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.buildid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccontentbuildercommitappbuildresponse() CContentBuilderCommitAppBuildResponse { +return CContentBuilderCommitAppBuildResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccontentbuildercommitappbuildresponse(o CContentBuilderCommitAppBuildResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccontentbuildercommitappbuildresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CContentBuilderCommitAppBuildResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccontentbuildercommitappbuildresponse_unpack(v)? +return i, unpacked +} +pub struct CContentBuilderSignInstallScriptRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +depotid u32 +has_depotid bool +install_script string +has_install_script bool +} +pub fn (o &CContentBuilderSignInstallScriptRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_depotid { +res << vproto.pack_uint32_field(o.depotid, 2) +} + +if o.has_install_script { +res << vproto.pack_string_field(o.install_script, 3) +} + +return res +} + +pub fn ccontentbuildersigninstallscriptrequest_unpack(buf []byte) ?CContentBuilderSignInstallScriptRequest { +mut res := CContentBuilderSignInstallScriptRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_depotid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.depotid = v +i = ii +} + +3 { +res.has_install_script = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.install_script = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccontentbuildersigninstallscriptrequest() CContentBuilderSignInstallScriptRequest { +return CContentBuilderSignInstallScriptRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccontentbuildersigninstallscriptrequest(o CContentBuilderSignInstallScriptRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccontentbuildersigninstallscriptrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CContentBuilderSignInstallScriptRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccontentbuildersigninstallscriptrequest_unpack(v)? +return i, unpacked +} +pub struct CContentBuilderSignInstallScriptResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +signed_install_script string +has_signed_install_script bool +} +pub fn (o &CContentBuilderSignInstallScriptResponse) pack() []byte { +mut res := []byte{} +if o.has_signed_install_script { +res << vproto.pack_string_field(o.signed_install_script, 1) +} + +return res +} + +pub fn ccontentbuildersigninstallscriptresponse_unpack(buf []byte) ?CContentBuilderSignInstallScriptResponse { +mut res := CContentBuilderSignInstallScriptResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_signed_install_script = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.signed_install_script = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccontentbuildersigninstallscriptresponse() CContentBuilderSignInstallScriptResponse { +return CContentBuilderSignInstallScriptResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccontentbuildersigninstallscriptresponse(o CContentBuilderSignInstallScriptResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccontentbuildersigninstallscriptresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CContentBuilderSignInstallScriptResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccontentbuildersigninstallscriptresponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_deviceauth.steamclient_pb.v b/proto/steammessages_deviceauth.steamclient_pb.v new file mode 100644 index 0000000..686d597 --- /dev/null +++ b/proto/steammessages_deviceauth.steamclient_pb.v @@ -0,0 +1,2037 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CDeviceAuthGetOwnAuthorizedDevicesRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +include_canceled bool +has_include_canceled bool +} +pub fn (o &CDeviceAuthGetOwnAuthorizedDevicesRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_include_canceled { +res << vproto.pack_bool_field(o.include_canceled, 2) +} + +return res +} + +pub fn cdeviceauthgetownauthorizeddevicesrequest_unpack(buf []byte) ?CDeviceAuthGetOwnAuthorizedDevicesRequest { +mut res := CDeviceAuthGetOwnAuthorizedDevicesRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_include_canceled = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.include_canceled = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthgetownauthorizeddevicesrequest() CDeviceAuthGetOwnAuthorizedDevicesRequest { +return CDeviceAuthGetOwnAuthorizedDevicesRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthgetownauthorizeddevicesrequest(o CDeviceAuthGetOwnAuthorizedDevicesRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthgetownauthorizeddevicesrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthGetOwnAuthorizedDevicesRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthgetownauthorizeddevicesrequest_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthGetOwnAuthorizedDevicesResponseDevice { +mut: +unknown_fields []vproto.UnknownField +pub mut: +auth_device_token u64 +has_auth_device_token bool +device_name string +has_device_name bool +is_pending bool +has_is_pending bool +is_canceled bool +has_is_canceled bool +last_time_used u32 +has_last_time_used bool +last_borrower_id u64 +has_last_borrower_id bool +last_app_played u32 +has_last_app_played bool +is_limited bool +has_is_limited bool +} +pub fn (o &CDeviceAuthGetOwnAuthorizedDevicesResponseDevice) pack() []byte { +mut res := []byte{} +if o.has_auth_device_token { +res << vproto.pack_64bit_field(o.auth_device_token, 1) +} + +if o.has_device_name { +res << vproto.pack_string_field(o.device_name, 2) +} + +if o.has_is_pending { +res << vproto.pack_bool_field(o.is_pending, 3) +} + +if o.has_is_canceled { +res << vproto.pack_bool_field(o.is_canceled, 4) +} + +if o.has_last_time_used { +res << vproto.pack_uint32_field(o.last_time_used, 5) +} + +if o.has_last_borrower_id { +res << vproto.pack_64bit_field(o.last_borrower_id, 6) +} + +if o.has_last_app_played { +res << vproto.pack_uint32_field(o.last_app_played, 7) +} + +if o.has_is_limited { +res << vproto.pack_bool_field(o.is_limited, 8) +} + +return res +} + +pub fn cdeviceauthgetownauthorizeddevicesresponsedevice_unpack(buf []byte) ?CDeviceAuthGetOwnAuthorizedDevicesResponseDevice { +mut res := CDeviceAuthGetOwnAuthorizedDevicesResponseDevice{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_auth_device_token = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.auth_device_token = v +i = ii +} + +2 { +res.has_device_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.device_name = v +i = ii +} + +3 { +res.has_is_pending = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_pending = v +i = ii +} + +4 { +res.has_is_canceled = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_canceled = v +i = ii +} + +5 { +res.has_last_time_used = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_time_used = v +i = ii +} + +6 { +res.has_last_borrower_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.last_borrower_id = v +i = ii +} + +7 { +res.has_last_app_played = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_app_played = v +i = ii +} + +8 { +res.has_is_limited = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_limited = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthgetownauthorizeddevicesresponsedevice() CDeviceAuthGetOwnAuthorizedDevicesResponseDevice { +return CDeviceAuthGetOwnAuthorizedDevicesResponseDevice{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthgetownauthorizeddevicesresponsedevice(o CDeviceAuthGetOwnAuthorizedDevicesResponseDevice, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthgetownauthorizeddevicesresponsedevice(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthGetOwnAuthorizedDevicesResponseDevice) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthgetownauthorizeddevicesresponsedevice_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthGetOwnAuthorizedDevicesResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +devices []CDeviceAuthGetOwnAuthorizedDevicesResponseDevice +} +pub fn (o &CDeviceAuthGetOwnAuthorizedDevicesResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.devices { +res << zzz_vproto_internal_pack_cdeviceauthgetownauthorizeddevicesresponsedevice(x, 1) +} + +return res +} + +pub fn cdeviceauthgetownauthorizeddevicesresponse_unpack(buf []byte) ?CDeviceAuthGetOwnAuthorizedDevicesResponse { +mut res := CDeviceAuthGetOwnAuthorizedDevicesResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cdeviceauthgetownauthorizeddevicesresponsedevice(cur_buf, tag_wiretype.wire_type)? +res.devices << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthgetownauthorizeddevicesresponse() CDeviceAuthGetOwnAuthorizedDevicesResponse { +return CDeviceAuthGetOwnAuthorizedDevicesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthgetownauthorizeddevicesresponse(o CDeviceAuthGetOwnAuthorizedDevicesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthgetownauthorizeddevicesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthGetOwnAuthorizedDevicesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthgetownauthorizeddevicesresponse_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthAcceptAuthorizationRequestRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +auth_device_token u64 +has_auth_device_token bool +auth_code u64 +has_auth_code bool +from_steamid u64 +has_from_steamid bool +} +pub fn (o &CDeviceAuthAcceptAuthorizationRequestRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_auth_device_token { +res << vproto.pack_64bit_field(o.auth_device_token, 2) +} + +if o.has_auth_code { +res << vproto.pack_64bit_field(o.auth_code, 3) +} + +if o.has_from_steamid { +res << vproto.pack_64bit_field(o.from_steamid, 4) +} + +return res +} + +pub fn cdeviceauthacceptauthorizationrequestrequest_unpack(buf []byte) ?CDeviceAuthAcceptAuthorizationRequestRequest { +mut res := CDeviceAuthAcceptAuthorizationRequestRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_auth_device_token = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.auth_device_token = v +i = ii +} + +3 { +res.has_auth_code = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.auth_code = v +i = ii +} + +4 { +res.has_from_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.from_steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthacceptauthorizationrequestrequest() CDeviceAuthAcceptAuthorizationRequestRequest { +return CDeviceAuthAcceptAuthorizationRequestRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthacceptauthorizationrequestrequest(o CDeviceAuthAcceptAuthorizationRequestRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthacceptauthorizationrequestrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthAcceptAuthorizationRequestRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthacceptauthorizationrequestrequest_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthAcceptAuthorizationRequestResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CDeviceAuthAcceptAuthorizationRequestResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cdeviceauthacceptauthorizationrequestresponse_unpack(buf []byte) ?CDeviceAuthAcceptAuthorizationRequestResponse { +res := CDeviceAuthAcceptAuthorizationRequestResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthacceptauthorizationrequestresponse() CDeviceAuthAcceptAuthorizationRequestResponse { +return CDeviceAuthAcceptAuthorizationRequestResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthacceptauthorizationrequestresponse(o CDeviceAuthAcceptAuthorizationRequestResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthacceptauthorizationrequestresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthAcceptAuthorizationRequestResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthacceptauthorizationrequestresponse_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthAuthorizeRemoteDeviceRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +auth_device_token u64 +has_auth_device_token bool +} +pub fn (o &CDeviceAuthAuthorizeRemoteDeviceRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_auth_device_token { +res << vproto.pack_64bit_field(o.auth_device_token, 2) +} + +return res +} + +pub fn cdeviceauthauthorizeremotedevicerequest_unpack(buf []byte) ?CDeviceAuthAuthorizeRemoteDeviceRequest { +mut res := CDeviceAuthAuthorizeRemoteDeviceRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_auth_device_token = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.auth_device_token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthauthorizeremotedevicerequest() CDeviceAuthAuthorizeRemoteDeviceRequest { +return CDeviceAuthAuthorizeRemoteDeviceRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthauthorizeremotedevicerequest(o CDeviceAuthAuthorizeRemoteDeviceRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthauthorizeremotedevicerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthAuthorizeRemoteDeviceRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthauthorizeremotedevicerequest_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthAuthorizeRemoteDeviceResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CDeviceAuthAuthorizeRemoteDeviceResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cdeviceauthauthorizeremotedeviceresponse_unpack(buf []byte) ?CDeviceAuthAuthorizeRemoteDeviceResponse { +res := CDeviceAuthAuthorizeRemoteDeviceResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthauthorizeremotedeviceresponse() CDeviceAuthAuthorizeRemoteDeviceResponse { +return CDeviceAuthAuthorizeRemoteDeviceResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthauthorizeremotedeviceresponse(o CDeviceAuthAuthorizeRemoteDeviceResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthauthorizeremotedeviceresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthAuthorizeRemoteDeviceResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthauthorizeremotedeviceresponse_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthDeauthorizeRemoteDeviceRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +auth_device_token u64 +has_auth_device_token bool +} +pub fn (o &CDeviceAuthDeauthorizeRemoteDeviceRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_auth_device_token { +res << vproto.pack_64bit_field(o.auth_device_token, 2) +} + +return res +} + +pub fn cdeviceauthdeauthorizeremotedevicerequest_unpack(buf []byte) ?CDeviceAuthDeauthorizeRemoteDeviceRequest { +mut res := CDeviceAuthDeauthorizeRemoteDeviceRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_auth_device_token = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.auth_device_token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthdeauthorizeremotedevicerequest() CDeviceAuthDeauthorizeRemoteDeviceRequest { +return CDeviceAuthDeauthorizeRemoteDeviceRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthdeauthorizeremotedevicerequest(o CDeviceAuthDeauthorizeRemoteDeviceRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthdeauthorizeremotedevicerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthDeauthorizeRemoteDeviceRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthdeauthorizeremotedevicerequest_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthDeauthorizeRemoteDeviceResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CDeviceAuthDeauthorizeRemoteDeviceResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cdeviceauthdeauthorizeremotedeviceresponse_unpack(buf []byte) ?CDeviceAuthDeauthorizeRemoteDeviceResponse { +res := CDeviceAuthDeauthorizeRemoteDeviceResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthdeauthorizeremotedeviceresponse() CDeviceAuthDeauthorizeRemoteDeviceResponse { +return CDeviceAuthDeauthorizeRemoteDeviceResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthdeauthorizeremotedeviceresponse(o CDeviceAuthDeauthorizeRemoteDeviceResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthdeauthorizeremotedeviceresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthDeauthorizeRemoteDeviceResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthdeauthorizeremotedeviceresponse_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthGetUsedAuthorizedDevicesRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +} +pub fn (o &CDeviceAuthGetUsedAuthorizedDevicesRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +return res +} + +pub fn cdeviceauthgetusedauthorizeddevicesrequest_unpack(buf []byte) ?CDeviceAuthGetUsedAuthorizedDevicesRequest { +mut res := CDeviceAuthGetUsedAuthorizedDevicesRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthgetusedauthorizeddevicesrequest() CDeviceAuthGetUsedAuthorizedDevicesRequest { +return CDeviceAuthGetUsedAuthorizedDevicesRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthgetusedauthorizeddevicesrequest(o CDeviceAuthGetUsedAuthorizedDevicesRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthgetusedauthorizeddevicesrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthGetUsedAuthorizedDevicesRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthgetusedauthorizeddevicesrequest_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthGetUsedAuthorizedDevicesResponseDevice { +mut: +unknown_fields []vproto.UnknownField +pub mut: +auth_device_token u64 +has_auth_device_token bool +device_name string +has_device_name bool +owner_steamid u64 +has_owner_steamid bool +last_time_used u32 +has_last_time_used bool +last_app_played u32 +has_last_app_played bool +} +pub fn (o &CDeviceAuthGetUsedAuthorizedDevicesResponseDevice) pack() []byte { +mut res := []byte{} +if o.has_auth_device_token { +res << vproto.pack_64bit_field(o.auth_device_token, 1) +} + +if o.has_device_name { +res << vproto.pack_string_field(o.device_name, 2) +} + +if o.has_owner_steamid { +res << vproto.pack_64bit_field(o.owner_steamid, 3) +} + +if o.has_last_time_used { +res << vproto.pack_uint32_field(o.last_time_used, 4) +} + +if o.has_last_app_played { +res << vproto.pack_uint32_field(o.last_app_played, 5) +} + +return res +} + +pub fn cdeviceauthgetusedauthorizeddevicesresponsedevice_unpack(buf []byte) ?CDeviceAuthGetUsedAuthorizedDevicesResponseDevice { +mut res := CDeviceAuthGetUsedAuthorizedDevicesResponseDevice{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_auth_device_token = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.auth_device_token = v +i = ii +} + +2 { +res.has_device_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.device_name = v +i = ii +} + +3 { +res.has_owner_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.owner_steamid = v +i = ii +} + +4 { +res.has_last_time_used = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_time_used = v +i = ii +} + +5 { +res.has_last_app_played = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_app_played = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthgetusedauthorizeddevicesresponsedevice() CDeviceAuthGetUsedAuthorizedDevicesResponseDevice { +return CDeviceAuthGetUsedAuthorizedDevicesResponseDevice{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthgetusedauthorizeddevicesresponsedevice(o CDeviceAuthGetUsedAuthorizedDevicesResponseDevice, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthgetusedauthorizeddevicesresponsedevice(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthGetUsedAuthorizedDevicesResponseDevice) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthgetusedauthorizeddevicesresponsedevice_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthGetUsedAuthorizedDevicesResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +devices []CDeviceAuthGetUsedAuthorizedDevicesResponseDevice +} +pub fn (o &CDeviceAuthGetUsedAuthorizedDevicesResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.devices { +res << zzz_vproto_internal_pack_cdeviceauthgetusedauthorizeddevicesresponsedevice(x, 1) +} + +return res +} + +pub fn cdeviceauthgetusedauthorizeddevicesresponse_unpack(buf []byte) ?CDeviceAuthGetUsedAuthorizedDevicesResponse { +mut res := CDeviceAuthGetUsedAuthorizedDevicesResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cdeviceauthgetusedauthorizeddevicesresponsedevice(cur_buf, tag_wiretype.wire_type)? +res.devices << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthgetusedauthorizeddevicesresponse() CDeviceAuthGetUsedAuthorizedDevicesResponse { +return CDeviceAuthGetUsedAuthorizedDevicesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthgetusedauthorizeddevicesresponse(o CDeviceAuthGetUsedAuthorizedDevicesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthgetusedauthorizeddevicesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthGetUsedAuthorizedDevicesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthgetusedauthorizeddevicesresponse_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthGetAuthorizedBorrowersRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +include_canceled bool +has_include_canceled bool +include_pending bool +has_include_pending bool +} +pub fn (o &CDeviceAuthGetAuthorizedBorrowersRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_include_canceled { +res << vproto.pack_bool_field(o.include_canceled, 2) +} + +if o.has_include_pending { +res << vproto.pack_bool_field(o.include_pending, 3) +} + +return res +} + +pub fn cdeviceauthgetauthorizedborrowersrequest_unpack(buf []byte) ?CDeviceAuthGetAuthorizedBorrowersRequest { +mut res := CDeviceAuthGetAuthorizedBorrowersRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_include_canceled = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.include_canceled = v +i = ii +} + +3 { +res.has_include_pending = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.include_pending = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthgetauthorizedborrowersrequest() CDeviceAuthGetAuthorizedBorrowersRequest { +return CDeviceAuthGetAuthorizedBorrowersRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthgetauthorizedborrowersrequest(o CDeviceAuthGetAuthorizedBorrowersRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthgetauthorizedborrowersrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthGetAuthorizedBorrowersRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthgetauthorizedborrowersrequest_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthGetAuthorizedBorrowersResponseBorrower { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +is_pending bool +has_is_pending bool +is_canceled bool +has_is_canceled bool +time_created u32 +has_time_created bool +} +pub fn (o &CDeviceAuthGetAuthorizedBorrowersResponseBorrower) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_is_pending { +res << vproto.pack_bool_field(o.is_pending, 2) +} + +if o.has_is_canceled { +res << vproto.pack_bool_field(o.is_canceled, 3) +} + +if o.has_time_created { +res << vproto.pack_uint32_field(o.time_created, 4) +} + +return res +} + +pub fn cdeviceauthgetauthorizedborrowersresponseborrower_unpack(buf []byte) ?CDeviceAuthGetAuthorizedBorrowersResponseBorrower { +mut res := CDeviceAuthGetAuthorizedBorrowersResponseBorrower{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_is_pending = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_pending = v +i = ii +} + +3 { +res.has_is_canceled = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_canceled = v +i = ii +} + +4 { +res.has_time_created = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_created = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthgetauthorizedborrowersresponseborrower() CDeviceAuthGetAuthorizedBorrowersResponseBorrower { +return CDeviceAuthGetAuthorizedBorrowersResponseBorrower{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthgetauthorizedborrowersresponseborrower(o CDeviceAuthGetAuthorizedBorrowersResponseBorrower, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthgetauthorizedborrowersresponseborrower(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthGetAuthorizedBorrowersResponseBorrower) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthgetauthorizedborrowersresponseborrower_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthGetAuthorizedBorrowersResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +borrowers []CDeviceAuthGetAuthorizedBorrowersResponseBorrower +} +pub fn (o &CDeviceAuthGetAuthorizedBorrowersResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.borrowers { +res << zzz_vproto_internal_pack_cdeviceauthgetauthorizedborrowersresponseborrower(x, 1) +} + +return res +} + +pub fn cdeviceauthgetauthorizedborrowersresponse_unpack(buf []byte) ?CDeviceAuthGetAuthorizedBorrowersResponse { +mut res := CDeviceAuthGetAuthorizedBorrowersResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cdeviceauthgetauthorizedborrowersresponseborrower(cur_buf, tag_wiretype.wire_type)? +res.borrowers << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthgetauthorizedborrowersresponse() CDeviceAuthGetAuthorizedBorrowersResponse { +return CDeviceAuthGetAuthorizedBorrowersResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthgetauthorizedborrowersresponse(o CDeviceAuthGetAuthorizedBorrowersResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthgetauthorizedborrowersresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthGetAuthorizedBorrowersResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthgetauthorizedborrowersresponse_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthAddAuthorizedBorrowersRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +steamid_borrower []u64 +} +pub fn (o &CDeviceAuthAddAuthorizedBorrowersRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +// [packed=false] +for _, x in o.steamid_borrower { +res << vproto.pack_64bit_field(x, 2) +} + +return res +} + +pub fn cdeviceauthaddauthorizedborrowersrequest_unpack(buf []byte) ?CDeviceAuthAddAuthorizedBorrowersRequest { +mut res := CDeviceAuthAddAuthorizedBorrowersRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_borrower << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthaddauthorizedborrowersrequest() CDeviceAuthAddAuthorizedBorrowersRequest { +return CDeviceAuthAddAuthorizedBorrowersRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthaddauthorizedborrowersrequest(o CDeviceAuthAddAuthorizedBorrowersRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthaddauthorizedborrowersrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthAddAuthorizedBorrowersRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthaddauthorizedborrowersrequest_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthAddAuthorizedBorrowersResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +seconds_to_wait int +has_seconds_to_wait bool +} +pub fn (o &CDeviceAuthAddAuthorizedBorrowersResponse) pack() []byte { +mut res := []byte{} +if o.has_seconds_to_wait { +res << vproto.pack_int32_field(o.seconds_to_wait, 1) +} + +return res +} + +pub fn cdeviceauthaddauthorizedborrowersresponse_unpack(buf []byte) ?CDeviceAuthAddAuthorizedBorrowersResponse { +mut res := CDeviceAuthAddAuthorizedBorrowersResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_seconds_to_wait = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_to_wait = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthaddauthorizedborrowersresponse() CDeviceAuthAddAuthorizedBorrowersResponse { +return CDeviceAuthAddAuthorizedBorrowersResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthaddauthorizedborrowersresponse(o CDeviceAuthAddAuthorizedBorrowersResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthaddauthorizedborrowersresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthAddAuthorizedBorrowersResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthaddauthorizedborrowersresponse_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthRemoveAuthorizedBorrowersRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +steamid_borrower []u64 +} +pub fn (o &CDeviceAuthRemoveAuthorizedBorrowersRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +// [packed=false] +for _, x in o.steamid_borrower { +res << vproto.pack_64bit_field(x, 2) +} + +return res +} + +pub fn cdeviceauthremoveauthorizedborrowersrequest_unpack(buf []byte) ?CDeviceAuthRemoveAuthorizedBorrowersRequest { +mut res := CDeviceAuthRemoveAuthorizedBorrowersRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_borrower << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthremoveauthorizedborrowersrequest() CDeviceAuthRemoveAuthorizedBorrowersRequest { +return CDeviceAuthRemoveAuthorizedBorrowersRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthremoveauthorizedborrowersrequest(o CDeviceAuthRemoveAuthorizedBorrowersRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthremoveauthorizedborrowersrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthRemoveAuthorizedBorrowersRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthremoveauthorizedborrowersrequest_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthRemoveAuthorizedBorrowersResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CDeviceAuthRemoveAuthorizedBorrowersResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cdeviceauthremoveauthorizedborrowersresponse_unpack(buf []byte) ?CDeviceAuthRemoveAuthorizedBorrowersResponse { +res := CDeviceAuthRemoveAuthorizedBorrowersResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthremoveauthorizedborrowersresponse() CDeviceAuthRemoveAuthorizedBorrowersResponse { +return CDeviceAuthRemoveAuthorizedBorrowersResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthremoveauthorizedborrowersresponse(o CDeviceAuthRemoveAuthorizedBorrowersResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthremoveauthorizedborrowersresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthRemoveAuthorizedBorrowersResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthremoveauthorizedborrowersresponse_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthGetAuthorizedAsBorrowerRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +include_canceled bool +has_include_canceled bool +include_pending bool +has_include_pending bool +} +pub fn (o &CDeviceAuthGetAuthorizedAsBorrowerRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_include_canceled { +res << vproto.pack_bool_field(o.include_canceled, 2) +} + +if o.has_include_pending { +res << vproto.pack_bool_field(o.include_pending, 3) +} + +return res +} + +pub fn cdeviceauthgetauthorizedasborrowerrequest_unpack(buf []byte) ?CDeviceAuthGetAuthorizedAsBorrowerRequest { +mut res := CDeviceAuthGetAuthorizedAsBorrowerRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_include_canceled = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.include_canceled = v +i = ii +} + +3 { +res.has_include_pending = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.include_pending = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthgetauthorizedasborrowerrequest() CDeviceAuthGetAuthorizedAsBorrowerRequest { +return CDeviceAuthGetAuthorizedAsBorrowerRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthgetauthorizedasborrowerrequest(o CDeviceAuthGetAuthorizedAsBorrowerRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthgetauthorizedasborrowerrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthGetAuthorizedAsBorrowerRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthgetauthorizedasborrowerrequest_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthGetAuthorizedAsBorrowerResponseLender { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +time_created u32 +has_time_created bool +is_pending bool +has_is_pending bool +is_canceled bool +has_is_canceled bool +is_used bool +has_is_used bool +} +pub fn (o &CDeviceAuthGetAuthorizedAsBorrowerResponseLender) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_time_created { +res << vproto.pack_uint32_field(o.time_created, 2) +} + +if o.has_is_pending { +res << vproto.pack_bool_field(o.is_pending, 3) +} + +if o.has_is_canceled { +res << vproto.pack_bool_field(o.is_canceled, 4) +} + +if o.has_is_used { +res << vproto.pack_bool_field(o.is_used, 5) +} + +return res +} + +pub fn cdeviceauthgetauthorizedasborrowerresponselender_unpack(buf []byte) ?CDeviceAuthGetAuthorizedAsBorrowerResponseLender { +mut res := CDeviceAuthGetAuthorizedAsBorrowerResponseLender{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_time_created = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_created = v +i = ii +} + +3 { +res.has_is_pending = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_pending = v +i = ii +} + +4 { +res.has_is_canceled = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_canceled = v +i = ii +} + +5 { +res.has_is_used = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_used = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthgetauthorizedasborrowerresponselender() CDeviceAuthGetAuthorizedAsBorrowerResponseLender { +return CDeviceAuthGetAuthorizedAsBorrowerResponseLender{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthgetauthorizedasborrowerresponselender(o CDeviceAuthGetAuthorizedAsBorrowerResponseLender, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthgetauthorizedasborrowerresponselender(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthGetAuthorizedAsBorrowerResponseLender) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthgetauthorizedasborrowerresponselender_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthGetAuthorizedAsBorrowerResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +lenders []CDeviceAuthGetAuthorizedAsBorrowerResponseLender +} +pub fn (o &CDeviceAuthGetAuthorizedAsBorrowerResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.lenders { +res << zzz_vproto_internal_pack_cdeviceauthgetauthorizedasborrowerresponselender(x, 1) +} + +return res +} + +pub fn cdeviceauthgetauthorizedasborrowerresponse_unpack(buf []byte) ?CDeviceAuthGetAuthorizedAsBorrowerResponse { +mut res := CDeviceAuthGetAuthorizedAsBorrowerResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cdeviceauthgetauthorizedasborrowerresponselender(cur_buf, tag_wiretype.wire_type)? +res.lenders << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthgetauthorizedasborrowerresponse() CDeviceAuthGetAuthorizedAsBorrowerResponse { +return CDeviceAuthGetAuthorizedAsBorrowerResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthgetauthorizedasborrowerresponse(o CDeviceAuthGetAuthorizedAsBorrowerResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthgetauthorizedasborrowerresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthGetAuthorizedAsBorrowerResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthgetauthorizedasborrowerresponse_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthGetExcludedGamesInLibraryRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +} +pub fn (o &CDeviceAuthGetExcludedGamesInLibraryRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +return res +} + +pub fn cdeviceauthgetexcludedgamesinlibraryrequest_unpack(buf []byte) ?CDeviceAuthGetExcludedGamesInLibraryRequest { +mut res := CDeviceAuthGetExcludedGamesInLibraryRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthgetexcludedgamesinlibraryrequest() CDeviceAuthGetExcludedGamesInLibraryRequest { +return CDeviceAuthGetExcludedGamesInLibraryRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthgetexcludedgamesinlibraryrequest(o CDeviceAuthGetExcludedGamesInLibraryRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthgetexcludedgamesinlibraryrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthGetExcludedGamesInLibraryRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthgetexcludedgamesinlibraryrequest_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthGetExcludedGamesInLibraryResponseExcludedGame { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +game_name string +has_game_name bool +vac_banned bool +has_vac_banned bool +package_excluded bool +has_package_excluded bool +} +pub fn (o &CDeviceAuthGetExcludedGamesInLibraryResponseExcludedGame) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_game_name { +res << vproto.pack_string_field(o.game_name, 2) +} + +if o.has_vac_banned { +res << vproto.pack_bool_field(o.vac_banned, 3) +} + +if o.has_package_excluded { +res << vproto.pack_bool_field(o.package_excluded, 4) +} + +return res +} + +pub fn cdeviceauthgetexcludedgamesinlibraryresponseexcludedgame_unpack(buf []byte) ?CDeviceAuthGetExcludedGamesInLibraryResponseExcludedGame { +mut res := CDeviceAuthGetExcludedGamesInLibraryResponseExcludedGame{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_game_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.game_name = v +i = ii +} + +3 { +res.has_vac_banned = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.vac_banned = v +i = ii +} + +4 { +res.has_package_excluded = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.package_excluded = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthgetexcludedgamesinlibraryresponseexcludedgame() CDeviceAuthGetExcludedGamesInLibraryResponseExcludedGame { +return CDeviceAuthGetExcludedGamesInLibraryResponseExcludedGame{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthgetexcludedgamesinlibraryresponseexcludedgame(o CDeviceAuthGetExcludedGamesInLibraryResponseExcludedGame, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthgetexcludedgamesinlibraryresponseexcludedgame(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthGetExcludedGamesInLibraryResponseExcludedGame) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthgetexcludedgamesinlibraryresponseexcludedgame_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthGetExcludedGamesInLibraryResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +excluded_games []CDeviceAuthGetExcludedGamesInLibraryResponseExcludedGame +} +pub fn (o &CDeviceAuthGetExcludedGamesInLibraryResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.excluded_games { +res << zzz_vproto_internal_pack_cdeviceauthgetexcludedgamesinlibraryresponseexcludedgame(x, 1) +} + +return res +} + +pub fn cdeviceauthgetexcludedgamesinlibraryresponse_unpack(buf []byte) ?CDeviceAuthGetExcludedGamesInLibraryResponse { +mut res := CDeviceAuthGetExcludedGamesInLibraryResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cdeviceauthgetexcludedgamesinlibraryresponseexcludedgame(cur_buf, tag_wiretype.wire_type)? +res.excluded_games << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthgetexcludedgamesinlibraryresponse() CDeviceAuthGetExcludedGamesInLibraryResponse { +return CDeviceAuthGetExcludedGamesInLibraryResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthgetexcludedgamesinlibraryresponse(o CDeviceAuthGetExcludedGamesInLibraryResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthgetexcludedgamesinlibraryresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthGetExcludedGamesInLibraryResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthgetexcludedgamesinlibraryresponse_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthGetBorrowerPlayHistoryRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +} +pub fn (o &CDeviceAuthGetBorrowerPlayHistoryRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +return res +} + +pub fn cdeviceauthgetborrowerplayhistoryrequest_unpack(buf []byte) ?CDeviceAuthGetBorrowerPlayHistoryRequest { +mut res := CDeviceAuthGetBorrowerPlayHistoryRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthgetborrowerplayhistoryrequest() CDeviceAuthGetBorrowerPlayHistoryRequest { +return CDeviceAuthGetBorrowerPlayHistoryRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthgetborrowerplayhistoryrequest(o CDeviceAuthGetBorrowerPlayHistoryRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthgetborrowerplayhistoryrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthGetBorrowerPlayHistoryRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthgetborrowerplayhistoryrequest_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthGetBorrowerPlayHistoryResponseGameHistory { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +time_last u32 +has_time_last bool +time_total u32 +has_time_total bool +} +pub fn (o &CDeviceAuthGetBorrowerPlayHistoryResponseGameHistory) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_time_last { +res << vproto.pack_uint32_field(o.time_last, 2) +} + +if o.has_time_total { +res << vproto.pack_uint32_field(o.time_total, 3) +} + +return res +} + +pub fn cdeviceauthgetborrowerplayhistoryresponsegamehistory_unpack(buf []byte) ?CDeviceAuthGetBorrowerPlayHistoryResponseGameHistory { +mut res := CDeviceAuthGetBorrowerPlayHistoryResponseGameHistory{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_time_last = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_last = v +i = ii +} + +3 { +res.has_time_total = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_total = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthgetborrowerplayhistoryresponsegamehistory() CDeviceAuthGetBorrowerPlayHistoryResponseGameHistory { +return CDeviceAuthGetBorrowerPlayHistoryResponseGameHistory{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthgetborrowerplayhistoryresponsegamehistory(o CDeviceAuthGetBorrowerPlayHistoryResponseGameHistory, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthgetborrowerplayhistoryresponsegamehistory(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthGetBorrowerPlayHistoryResponseGameHistory) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthgetborrowerplayhistoryresponsegamehistory_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthGetBorrowerPlayHistoryResponseLenderHistory { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +game_history []CDeviceAuthGetBorrowerPlayHistoryResponseGameHistory +} +pub fn (o &CDeviceAuthGetBorrowerPlayHistoryResponseLenderHistory) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +// [packed=false] +for _, x in o.game_history { +res << zzz_vproto_internal_pack_cdeviceauthgetborrowerplayhistoryresponsegamehistory(x, 2) +} + +return res +} + +pub fn cdeviceauthgetborrowerplayhistoryresponselenderhistory_unpack(buf []byte) ?CDeviceAuthGetBorrowerPlayHistoryResponseLenderHistory { +mut res := CDeviceAuthGetBorrowerPlayHistoryResponseLenderHistory{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cdeviceauthgetborrowerplayhistoryresponsegamehistory(cur_buf, tag_wiretype.wire_type)? +res.game_history << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthgetborrowerplayhistoryresponselenderhistory() CDeviceAuthGetBorrowerPlayHistoryResponseLenderHistory { +return CDeviceAuthGetBorrowerPlayHistoryResponseLenderHistory{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthgetborrowerplayhistoryresponselenderhistory(o CDeviceAuthGetBorrowerPlayHistoryResponseLenderHistory, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthgetborrowerplayhistoryresponselenderhistory(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthGetBorrowerPlayHistoryResponseLenderHistory) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthgetborrowerplayhistoryresponselenderhistory_unpack(v)? +return i, unpacked +} +pub struct CDeviceAuthGetBorrowerPlayHistoryResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +lender_history []CDeviceAuthGetBorrowerPlayHistoryResponseLenderHistory +} +pub fn (o &CDeviceAuthGetBorrowerPlayHistoryResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.lender_history { +res << zzz_vproto_internal_pack_cdeviceauthgetborrowerplayhistoryresponselenderhistory(x, 1) +} + +return res +} + +pub fn cdeviceauthgetborrowerplayhistoryresponse_unpack(buf []byte) ?CDeviceAuthGetBorrowerPlayHistoryResponse { +mut res := CDeviceAuthGetBorrowerPlayHistoryResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cdeviceauthgetborrowerplayhistoryresponselenderhistory(cur_buf, tag_wiretype.wire_type)? +res.lender_history << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeviceauthgetborrowerplayhistoryresponse() CDeviceAuthGetBorrowerPlayHistoryResponse { +return CDeviceAuthGetBorrowerPlayHistoryResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeviceauthgetborrowerplayhistoryresponse(o CDeviceAuthGetBorrowerPlayHistoryResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeviceauthgetborrowerplayhistoryresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeviceAuthGetBorrowerPlayHistoryResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeviceauthgetborrowerplayhistoryresponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_econ.steamclient_pb.v b/proto/steammessages_econ.steamclient_pb.v new file mode 100644 index 0000000..0dd9180 --- /dev/null +++ b/proto/steammessages_econ.steamclient_pb.v @@ -0,0 +1,1178 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CEconGetTradeOfferAccessTokenRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +generate_new_token bool +has_generate_new_token bool +} +pub fn (o &CEconGetTradeOfferAccessTokenRequest) pack() []byte { +mut res := []byte{} +if o.has_generate_new_token { +res << vproto.pack_bool_field(o.generate_new_token, 1) +} + +return res +} + +pub fn cecongettradeofferaccesstokenrequest_unpack(buf []byte) ?CEconGetTradeOfferAccessTokenRequest { +mut res := CEconGetTradeOfferAccessTokenRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_generate_new_token = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.generate_new_token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cecongettradeofferaccesstokenrequest() CEconGetTradeOfferAccessTokenRequest { +return CEconGetTradeOfferAccessTokenRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cecongettradeofferaccesstokenrequest(o CEconGetTradeOfferAccessTokenRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cecongettradeofferaccesstokenrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CEconGetTradeOfferAccessTokenRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cecongettradeofferaccesstokenrequest_unpack(v)? +return i, unpacked +} +pub struct CEconGetTradeOfferAccessTokenResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +trade_offer_access_token string +has_trade_offer_access_token bool +} +pub fn (o &CEconGetTradeOfferAccessTokenResponse) pack() []byte { +mut res := []byte{} +if o.has_trade_offer_access_token { +res << vproto.pack_string_field(o.trade_offer_access_token, 1) +} + +return res +} + +pub fn cecongettradeofferaccesstokenresponse_unpack(buf []byte) ?CEconGetTradeOfferAccessTokenResponse { +mut res := CEconGetTradeOfferAccessTokenResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_trade_offer_access_token = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.trade_offer_access_token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cecongettradeofferaccesstokenresponse() CEconGetTradeOfferAccessTokenResponse { +return CEconGetTradeOfferAccessTokenResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cecongettradeofferaccesstokenresponse(o CEconGetTradeOfferAccessTokenResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cecongettradeofferaccesstokenresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CEconGetTradeOfferAccessTokenResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cecongettradeofferaccesstokenresponse_unpack(v)? +return i, unpacked +} +pub struct CEconClientGetItemShopOverlayAuthURlrequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +return_url string +has_return_url bool +} +pub fn (o &CEconClientGetItemShopOverlayAuthURlrequest) pack() []byte { +mut res := []byte{} +if o.has_return_url { +res << vproto.pack_string_field(o.return_url, 1) +} + +return res +} + +pub fn ceconclientgetitemshopoverlayauthurlrequest_unpack(buf []byte) ?CEconClientGetItemShopOverlayAuthURlrequest { +mut res := CEconClientGetItemShopOverlayAuthURlrequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_return_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.return_url = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ceconclientgetitemshopoverlayauthurlrequest() CEconClientGetItemShopOverlayAuthURlrequest { +return CEconClientGetItemShopOverlayAuthURlrequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ceconclientgetitemshopoverlayauthurlrequest(o CEconClientGetItemShopOverlayAuthURlrequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ceconclientgetitemshopoverlayauthurlrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CEconClientGetItemShopOverlayAuthURlrequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ceconclientgetitemshopoverlayauthurlrequest_unpack(v)? +return i, unpacked +} +pub struct CEconClientGetItemShopOverlayAuthURlresponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +url string +has_url bool +} +pub fn (o &CEconClientGetItemShopOverlayAuthURlresponse) pack() []byte { +mut res := []byte{} +if o.has_url { +res << vproto.pack_string_field(o.url, 1) +} + +return res +} + +pub fn ceconclientgetitemshopoverlayauthurlresponse_unpack(buf []byte) ?CEconClientGetItemShopOverlayAuthURlresponse { +mut res := CEconClientGetItemShopOverlayAuthURlresponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ceconclientgetitemshopoverlayauthurlresponse() CEconClientGetItemShopOverlayAuthURlresponse { +return CEconClientGetItemShopOverlayAuthURlresponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ceconclientgetitemshopoverlayauthurlresponse(o CEconClientGetItemShopOverlayAuthURlresponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ceconclientgetitemshopoverlayauthurlresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CEconClientGetItemShopOverlayAuthURlresponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ceconclientgetitemshopoverlayauthurlresponse_unpack(v)? +return i, unpacked +} +pub struct CEconGetAssetClassInfoRequestClass { +mut: +unknown_fields []vproto.UnknownField +pub mut: +classid u64 +has_classid bool +instanceid u64 +has_instanceid bool +} +pub fn (o &CEconGetAssetClassInfoRequestClass) pack() []byte { +mut res := []byte{} +if o.has_classid { +res << vproto.pack_uint64_field(o.classid, 1) +} + +if o.has_instanceid { +res << vproto.pack_uint64_field(o.instanceid, 2) +} + +return res +} + +pub fn cecongetassetclassinforequestclass_unpack(buf []byte) ?CEconGetAssetClassInfoRequestClass { +mut res := CEconGetAssetClassInfoRequestClass{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_classid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.classid = v +i = ii +} + +2 { +res.has_instanceid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.instanceid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cecongetassetclassinforequestclass() CEconGetAssetClassInfoRequestClass { +return CEconGetAssetClassInfoRequestClass{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cecongetassetclassinforequestclass(o CEconGetAssetClassInfoRequestClass, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cecongetassetclassinforequestclass(buf []byte, tag_wiretype vproto.WireType) ?(int, CEconGetAssetClassInfoRequestClass) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cecongetassetclassinforequestclass_unpack(v)? +return i, unpacked +} +pub struct CEconGetAssetClassInfoRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +language string +has_language bool +appid u32 +has_appid bool +classes []CEconGetAssetClassInfoRequestClass +} +pub fn (o &CEconGetAssetClassInfoRequest) pack() []byte { +mut res := []byte{} +if o.has_language { +res << vproto.pack_string_field(o.language, 1) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 2) +} + +// [packed=false] +for _, x in o.classes { +res << zzz_vproto_internal_pack_cecongetassetclassinforequestclass(x, 3) +} + +return res +} + +pub fn cecongetassetclassinforequest_unpack(buf []byte) ?CEconGetAssetClassInfoRequest { +mut res := CEconGetAssetClassInfoRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_language = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +2 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cecongetassetclassinforequestclass(cur_buf, tag_wiretype.wire_type)? +res.classes << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cecongetassetclassinforequest() CEconGetAssetClassInfoRequest { +return CEconGetAssetClassInfoRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cecongetassetclassinforequest(o CEconGetAssetClassInfoRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cecongetassetclassinforequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CEconGetAssetClassInfoRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cecongetassetclassinforequest_unpack(v)? +return i, unpacked +} +pub struct CEconItemDescriptionLine { +mut: +unknown_fields []vproto.UnknownField +pub mut: +@type string +has_type bool +value string +has_value bool +color string +has_color bool +label string +has_label bool +} +pub fn (o &CEconItemDescriptionLine) pack() []byte { +mut res := []byte{} +if o.has_type { +res << vproto.pack_string_field(o.@type, 1) +} + +if o.has_value { +res << vproto.pack_string_field(o.value, 2) +} + +if o.has_color { +res << vproto.pack_string_field(o.color, 3) +} + +if o.has_label { +res << vproto.pack_string_field(o.label, 4) +} + +return res +} + +pub fn ceconitemdescriptionline_unpack(buf []byte) ?CEconItemDescriptionLine { +mut res := CEconItemDescriptionLine{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_type = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.@type = v +i = ii +} + +2 { +res.has_value = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.value = v +i = ii +} + +3 { +res.has_color = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.color = v +i = ii +} + +4 { +res.has_label = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.label = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ceconitemdescriptionline() CEconItemDescriptionLine { +return CEconItemDescriptionLine{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ceconitemdescriptionline(o CEconItemDescriptionLine, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ceconitemdescriptionline(buf []byte, tag_wiretype vproto.WireType) ?(int, CEconItemDescriptionLine) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ceconitemdescriptionline_unpack(v)? +return i, unpacked +} +pub struct CEconItemAction { +mut: +unknown_fields []vproto.UnknownField +pub mut: +link string +has_link bool +name string +has_name bool +} +pub fn (o &CEconItemAction) pack() []byte { +mut res := []byte{} +if o.has_link { +res << vproto.pack_string_field(o.link, 1) +} + +if o.has_name { +res << vproto.pack_string_field(o.name, 2) +} + +return res +} + +pub fn ceconitemaction_unpack(buf []byte) ?CEconItemAction { +mut res := CEconItemAction{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_link = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.link = v +i = ii +} + +2 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ceconitemaction() CEconItemAction { +return CEconItemAction{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ceconitemaction(o CEconItemAction, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ceconitemaction(buf []byte, tag_wiretype vproto.WireType) ?(int, CEconItemAction) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ceconitemaction_unpack(v)? +return i, unpacked +} +pub struct CEconItemDescription { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid int +has_appid bool +classid u64 +has_classid bool +instanceid u64 +has_instanceid bool +currency bool +has_currency bool +background_color string +has_background_color bool +icon_url string +has_icon_url bool +icon_url_large string +has_icon_url_large bool +descriptions []CEconItemDescriptionLine +tradable bool +has_tradable bool +actions []CEconItemAction +owner_descriptions []CEconItemDescriptionLine +owner_actions []CEconItemAction +fraudwarnings []string +name string +has_name bool +name_color string +has_name_color bool +@type string +has_type bool +market_name string +has_market_name bool +market_hash_name string +has_market_hash_name bool +market_fee string +has_market_fee bool +market_fee_app int +has_market_fee_app bool +contained_item CEconItemDescription +has_contained_item bool +market_actions []CEconItemAction +commodity bool +has_commodity bool +market_tradable_restriction int +has_market_tradable_restriction bool +market_marketable_restriction int +has_market_marketable_restriction bool +marketable bool +has_marketable bool +tags []CEconItemTag +item_expiration string +has_item_expiration bool +market_buy_country_restriction string +has_market_buy_country_restriction bool +market_sell_country_restriction string +has_market_sell_country_restriction bool +} +pub fn (o &CEconItemDescription) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_int32_field(o.appid, 1) +} + +if o.has_classid { +res << vproto.pack_uint64_field(o.classid, 2) +} + +if o.has_instanceid { +res << vproto.pack_uint64_field(o.instanceid, 3) +} + +if o.has_currency { +res << vproto.pack_bool_field(o.currency, 4) +} + +if o.has_background_color { +res << vproto.pack_string_field(o.background_color, 5) +} + +if o.has_icon_url { +res << vproto.pack_string_field(o.icon_url, 6) +} + +if o.has_icon_url_large { +res << vproto.pack_string_field(o.icon_url_large, 7) +} + +// [packed=false] +for _, x in o.descriptions { +res << zzz_vproto_internal_pack_ceconitemdescriptionline(x, 8) +} + +if o.has_tradable { +res << vproto.pack_bool_field(o.tradable, 9) +} + +// [packed=false] +for _, x in o.actions { +res << zzz_vproto_internal_pack_ceconitemaction(x, 10) +} + +// [packed=false] +for _, x in o.owner_descriptions { +res << zzz_vproto_internal_pack_ceconitemdescriptionline(x, 11) +} + +// [packed=false] +for _, x in o.owner_actions { +res << zzz_vproto_internal_pack_ceconitemaction(x, 12) +} + +// [packed=false] +for _, x in o.fraudwarnings { +res << vproto.pack_string_field(x, 13) +} + +if o.has_name { +res << vproto.pack_string_field(o.name, 14) +} + +if o.has_name_color { +res << vproto.pack_string_field(o.name_color, 15) +} + +if o.has_type { +res << vproto.pack_string_field(o.@type, 16) +} + +if o.has_market_name { +res << vproto.pack_string_field(o.market_name, 17) +} + +if o.has_market_hash_name { +res << vproto.pack_string_field(o.market_hash_name, 18) +} + +if o.has_market_fee { +res << vproto.pack_string_field(o.market_fee, 19) +} + +if o.has_market_fee_app { +res << vproto.pack_int32_field(o.market_fee_app, 28) +} + +if o.has_contained_item { +res << zzz_vproto_internal_pack_ceconitemdescription(o.contained_item, 20) +} + +// [packed=false] +for _, x in o.market_actions { +res << zzz_vproto_internal_pack_ceconitemaction(x, 21) +} + +if o.has_commodity { +res << vproto.pack_bool_field(o.commodity, 22) +} + +if o.has_market_tradable_restriction { +res << vproto.pack_int32_field(o.market_tradable_restriction, 23) +} + +if o.has_market_marketable_restriction { +res << vproto.pack_int32_field(o.market_marketable_restriction, 24) +} + +if o.has_marketable { +res << vproto.pack_bool_field(o.marketable, 25) +} + +// [packed=false] +for _, x in o.tags { +res << zzz_vproto_internal_pack_ceconitemtag(x, 26) +} + +if o.has_item_expiration { +res << vproto.pack_string_field(o.item_expiration, 27) +} + +if o.has_market_buy_country_restriction { +res << vproto.pack_string_field(o.market_buy_country_restriction, 30) +} + +if o.has_market_sell_country_restriction { +res << vproto.pack_string_field(o.market_sell_country_restriction, 31) +} + +return res +} + +pub fn ceconitemdescription_unpack(buf []byte) ?CEconItemDescription { +mut res := CEconItemDescription{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_classid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.classid = v +i = ii +} + +3 { +res.has_instanceid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.instanceid = v +i = ii +} + +4 { +res.has_currency = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.currency = v +i = ii +} + +5 { +res.has_background_color = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.background_color = v +i = ii +} + +6 { +res.has_icon_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.icon_url = v +i = ii +} + +7 { +res.has_icon_url_large = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.icon_url_large = v +i = ii +} + +8 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_ceconitemdescriptionline(cur_buf, tag_wiretype.wire_type)? +res.descriptions << v +i = ii +} + +9 { +res.has_tradable = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.tradable = v +i = ii +} + +10 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_ceconitemaction(cur_buf, tag_wiretype.wire_type)? +res.actions << v +i = ii +} + +11 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_ceconitemdescriptionline(cur_buf, tag_wiretype.wire_type)? +res.owner_descriptions << v +i = ii +} + +12 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_ceconitemaction(cur_buf, tag_wiretype.wire_type)? +res.owner_actions << v +i = ii +} + +13 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.fraudwarnings << v +i = ii +} + +14 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +15 { +res.has_name_color = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name_color = v +i = ii +} + +16 { +res.has_type = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.@type = v +i = ii +} + +17 { +res.has_market_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.market_name = v +i = ii +} + +18 { +res.has_market_hash_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.market_hash_name = v +i = ii +} + +19 { +res.has_market_fee = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.market_fee = v +i = ii +} + +28 { +res.has_market_fee_app = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.market_fee_app = v +i = ii +} + +20 { +res.has_contained_item = true +ii, v := zzz_vproto_internal_unpack_ceconitemdescription(cur_buf, tag_wiretype.wire_type)? +res.contained_item = v +i = ii +} + +21 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_ceconitemaction(cur_buf, tag_wiretype.wire_type)? +res.market_actions << v +i = ii +} + +22 { +res.has_commodity = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.commodity = v +i = ii +} + +23 { +res.has_market_tradable_restriction = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.market_tradable_restriction = v +i = ii +} + +24 { +res.has_market_marketable_restriction = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.market_marketable_restriction = v +i = ii +} + +25 { +res.has_marketable = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.marketable = v +i = ii +} + +26 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_ceconitemtag(cur_buf, tag_wiretype.wire_type)? +res.tags << v +i = ii +} + +27 { +res.has_item_expiration = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.item_expiration = v +i = ii +} + +30 { +res.has_market_buy_country_restriction = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.market_buy_country_restriction = v +i = ii +} + +31 { +res.has_market_sell_country_restriction = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.market_sell_country_restriction = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ceconitemdescription() CEconItemDescription { +return CEconItemDescription{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ceconitemdescription(o CEconItemDescription, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ceconitemdescription(buf []byte, tag_wiretype vproto.WireType) ?(int, CEconItemDescription) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ceconitemdescription_unpack(v)? +return i, unpacked +} +pub struct CEconItemTag { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +category string +has_category bool +internal_name string +has_internal_name bool +localized_category_name string +has_localized_category_name bool +localized_tag_name string +has_localized_tag_name bool +color string +has_color bool +} +pub fn (o &CEconItemTag) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_category { +res << vproto.pack_string_field(o.category, 2) +} + +if o.has_internal_name { +res << vproto.pack_string_field(o.internal_name, 3) +} + +if o.has_localized_category_name { +res << vproto.pack_string_field(o.localized_category_name, 4) +} + +if o.has_localized_tag_name { +res << vproto.pack_string_field(o.localized_tag_name, 5) +} + +if o.has_color { +res << vproto.pack_string_field(o.color, 6) +} + +return res +} + +pub fn ceconitemtag_unpack(buf []byte) ?CEconItemTag { +mut res := CEconItemTag{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_category = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.category = v +i = ii +} + +3 { +res.has_internal_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.internal_name = v +i = ii +} + +4 { +res.has_localized_category_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.localized_category_name = v +i = ii +} + +5 { +res.has_localized_tag_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.localized_tag_name = v +i = ii +} + +6 { +res.has_color = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.color = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ceconitemtag() CEconItemTag { +return CEconItemTag{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ceconitemtag(o CEconItemTag, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ceconitemtag(buf []byte, tag_wiretype vproto.WireType) ?(int, CEconItemTag) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ceconitemtag_unpack(v)? +return i, unpacked +} +pub struct CEconGetAssetClassInfoResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +descriptions []CEconItemDescription +} +pub fn (o &CEconGetAssetClassInfoResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.descriptions { +res << zzz_vproto_internal_pack_ceconitemdescription(x, 1) +} + +return res +} + +pub fn cecongetassetclassinforesponse_unpack(buf []byte) ?CEconGetAssetClassInfoResponse { +mut res := CEconGetAssetClassInfoResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_ceconitemdescription(cur_buf, tag_wiretype.wire_type)? +res.descriptions << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cecongetassetclassinforesponse() CEconGetAssetClassInfoResponse { +return CEconGetAssetClassInfoResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cecongetassetclassinforesponse(o CEconGetAssetClassInfoResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cecongetassetclassinforesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CEconGetAssetClassInfoResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cecongetassetclassinforesponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_friendmessages.steamclient_pb.v b/proto/steammessages_friendmessages.steamclient_pb.v new file mode 100644 index 0000000..ba65d6f --- /dev/null +++ b/proto/steammessages_friendmessages.steamclient_pb.v @@ -0,0 +1,1171 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CFriendMessagesGetRecentMessagesRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid1 u64 +has_steamid1 bool +steamid2 u64 +has_steamid2 bool +count u32 +has_count bool +most_recent_conversation bool +has_most_recent_conversation bool +rtime32_start_time u32 +has_rtime32_start_time bool +bbcode_format bool +has_bbcode_format bool +start_ordinal u32 +has_start_ordinal bool +time_last u32 +has_time_last bool +ordinal_last u32 +has_ordinal_last bool +} +pub fn (o &CFriendMessagesGetRecentMessagesRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid1 { +res << vproto.pack_64bit_field(o.steamid1, 1) +} + +if o.has_steamid2 { +res << vproto.pack_64bit_field(o.steamid2, 2) +} + +if o.has_count { +res << vproto.pack_uint32_field(o.count, 3) +} + +if o.has_most_recent_conversation { +res << vproto.pack_bool_field(o.most_recent_conversation, 4) +} + +if o.has_rtime32_start_time { +res << vproto.pack_32bit_field(o.rtime32_start_time, 5) +} + +if o.has_bbcode_format { +res << vproto.pack_bool_field(o.bbcode_format, 6) +} + +if o.has_start_ordinal { +res << vproto.pack_uint32_field(o.start_ordinal, 7) +} + +if o.has_time_last { +res << vproto.pack_uint32_field(o.time_last, 8) +} + +if o.has_ordinal_last { +res << vproto.pack_uint32_field(o.ordinal_last, 9) +} + +return res +} + +pub fn cfriendmessagesgetrecentmessagesrequest_unpack(buf []byte) ?CFriendMessagesGetRecentMessagesRequest { +mut res := CFriendMessagesGetRecentMessagesRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid1 = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid1 = v +i = ii +} + +2 { +res.has_steamid2 = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid2 = v +i = ii +} + +3 { +res.has_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.count = v +i = ii +} + +4 { +res.has_most_recent_conversation = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.most_recent_conversation = v +i = ii +} + +5 { +res.has_rtime32_start_time = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.rtime32_start_time = v +i = ii +} + +6 { +res.has_bbcode_format = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.bbcode_format = v +i = ii +} + +7 { +res.has_start_ordinal = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.start_ordinal = v +i = ii +} + +8 { +res.has_time_last = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_last = v +i = ii +} + +9 { +res.has_ordinal_last = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ordinal_last = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cfriendmessagesgetrecentmessagesrequest() CFriendMessagesGetRecentMessagesRequest { +return CFriendMessagesGetRecentMessagesRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cfriendmessagesgetrecentmessagesrequest(o CFriendMessagesGetRecentMessagesRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cfriendmessagesgetrecentmessagesrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CFriendMessagesGetRecentMessagesRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cfriendmessagesgetrecentmessagesrequest_unpack(v)? +return i, unpacked +} +pub struct CFriendMessagesGetRecentMessagesResponseFriendMessage { +mut: +unknown_fields []vproto.UnknownField +pub mut: +accountid u32 +has_accountid bool +timestamp u32 +has_timestamp bool +message string +has_message bool +ordinal u32 +has_ordinal bool +} +pub fn (o &CFriendMessagesGetRecentMessagesResponseFriendMessage) pack() []byte { +mut res := []byte{} +if o.has_accountid { +res << vproto.pack_uint32_field(o.accountid, 1) +} + +if o.has_timestamp { +res << vproto.pack_uint32_field(o.timestamp, 2) +} + +if o.has_message { +res << vproto.pack_string_field(o.message, 3) +} + +if o.has_ordinal { +res << vproto.pack_uint32_field(o.ordinal, 4) +} + +return res +} + +pub fn cfriendmessagesgetrecentmessagesresponsefriendmessage_unpack(buf []byte) ?CFriendMessagesGetRecentMessagesResponseFriendMessage { +mut res := CFriendMessagesGetRecentMessagesResponseFriendMessage{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_accountid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.accountid = v +i = ii +} + +2 { +res.has_timestamp = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp = v +i = ii +} + +3 { +res.has_message = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.message = v +i = ii +} + +4 { +res.has_ordinal = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ordinal = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cfriendmessagesgetrecentmessagesresponsefriendmessage() CFriendMessagesGetRecentMessagesResponseFriendMessage { +return CFriendMessagesGetRecentMessagesResponseFriendMessage{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cfriendmessagesgetrecentmessagesresponsefriendmessage(o CFriendMessagesGetRecentMessagesResponseFriendMessage, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cfriendmessagesgetrecentmessagesresponsefriendmessage(buf []byte, tag_wiretype vproto.WireType) ?(int, CFriendMessagesGetRecentMessagesResponseFriendMessage) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cfriendmessagesgetrecentmessagesresponsefriendmessage_unpack(v)? +return i, unpacked +} +pub struct CFriendMessagesGetRecentMessagesResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +messages []CFriendMessagesGetRecentMessagesResponseFriendMessage +more_available bool +has_more_available bool +} +pub fn (o &CFriendMessagesGetRecentMessagesResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.messages { +res << zzz_vproto_internal_pack_cfriendmessagesgetrecentmessagesresponsefriendmessage(x, 1) +} + +if o.has_more_available { +res << vproto.pack_bool_field(o.more_available, 4) +} + +return res +} + +pub fn cfriendmessagesgetrecentmessagesresponse_unpack(buf []byte) ?CFriendMessagesGetRecentMessagesResponse { +mut res := CFriendMessagesGetRecentMessagesResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cfriendmessagesgetrecentmessagesresponsefriendmessage(cur_buf, tag_wiretype.wire_type)? +res.messages << v +i = ii +} + +4 { +res.has_more_available = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.more_available = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cfriendmessagesgetrecentmessagesresponse() CFriendMessagesGetRecentMessagesResponse { +return CFriendMessagesGetRecentMessagesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cfriendmessagesgetrecentmessagesresponse(o CFriendMessagesGetRecentMessagesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cfriendmessagesgetrecentmessagesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CFriendMessagesGetRecentMessagesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cfriendmessagesgetrecentmessagesresponse_unpack(v)? +return i, unpacked +} +pub struct CFriendsMessagesGetActiveMessageSessionsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +lastmessage_since u32 +has_lastmessage_since bool +only_sessions_with_messages bool +has_only_sessions_with_messages bool +} +pub fn (o &CFriendsMessagesGetActiveMessageSessionsRequest) pack() []byte { +mut res := []byte{} +if o.has_lastmessage_since { +res << vproto.pack_uint32_field(o.lastmessage_since, 1) +} + +if o.has_only_sessions_with_messages { +res << vproto.pack_bool_field(o.only_sessions_with_messages, 2) +} + +return res +} + +pub fn cfriendsmessagesgetactivemessagesessionsrequest_unpack(buf []byte) ?CFriendsMessagesGetActiveMessageSessionsRequest { +mut res := CFriendsMessagesGetActiveMessageSessionsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_lastmessage_since = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.lastmessage_since = v +i = ii +} + +2 { +res.has_only_sessions_with_messages = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.only_sessions_with_messages = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cfriendsmessagesgetactivemessagesessionsrequest() CFriendsMessagesGetActiveMessageSessionsRequest { +return CFriendsMessagesGetActiveMessageSessionsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cfriendsmessagesgetactivemessagesessionsrequest(o CFriendsMessagesGetActiveMessageSessionsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cfriendsmessagesgetactivemessagesessionsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CFriendsMessagesGetActiveMessageSessionsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cfriendsmessagesgetactivemessagesessionsrequest_unpack(v)? +return i, unpacked +} +pub struct CFriendsMessagesGetActiveMessageSessionsResponseFriendMessageSession { +mut: +unknown_fields []vproto.UnknownField +pub mut: +accountid_friend u32 +has_accountid_friend bool +last_message u32 +has_last_message bool +last_view u32 +has_last_view bool +unread_message_count u32 +has_unread_message_count bool +} +pub fn (o &CFriendsMessagesGetActiveMessageSessionsResponseFriendMessageSession) pack() []byte { +mut res := []byte{} +if o.has_accountid_friend { +res << vproto.pack_uint32_field(o.accountid_friend, 1) +} + +if o.has_last_message { +res << vproto.pack_uint32_field(o.last_message, 2) +} + +if o.has_last_view { +res << vproto.pack_uint32_field(o.last_view, 3) +} + +if o.has_unread_message_count { +res << vproto.pack_uint32_field(o.unread_message_count, 4) +} + +return res +} + +pub fn cfriendsmessagesgetactivemessagesessionsresponsefriendmessagesession_unpack(buf []byte) ?CFriendsMessagesGetActiveMessageSessionsResponseFriendMessageSession { +mut res := CFriendsMessagesGetActiveMessageSessionsResponseFriendMessageSession{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_accountid_friend = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.accountid_friend = v +i = ii +} + +2 { +res.has_last_message = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_message = v +i = ii +} + +3 { +res.has_last_view = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_view = v +i = ii +} + +4 { +res.has_unread_message_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.unread_message_count = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cfriendsmessagesgetactivemessagesessionsresponsefriendmessagesession() CFriendsMessagesGetActiveMessageSessionsResponseFriendMessageSession { +return CFriendsMessagesGetActiveMessageSessionsResponseFriendMessageSession{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cfriendsmessagesgetactivemessagesessionsresponsefriendmessagesession(o CFriendsMessagesGetActiveMessageSessionsResponseFriendMessageSession, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cfriendsmessagesgetactivemessagesessionsresponsefriendmessagesession(buf []byte, tag_wiretype vproto.WireType) ?(int, CFriendsMessagesGetActiveMessageSessionsResponseFriendMessageSession) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cfriendsmessagesgetactivemessagesessionsresponsefriendmessagesession_unpack(v)? +return i, unpacked +} +pub struct CFriendsMessagesGetActiveMessageSessionsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +message_sessions []CFriendsMessagesGetActiveMessageSessionsResponseFriendMessageSession +timestamp u32 +has_timestamp bool +} +pub fn (o &CFriendsMessagesGetActiveMessageSessionsResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.message_sessions { +res << zzz_vproto_internal_pack_cfriendsmessagesgetactivemessagesessionsresponsefriendmessagesession(x, 1) +} + +if o.has_timestamp { +res << vproto.pack_uint32_field(o.timestamp, 2) +} + +return res +} + +pub fn cfriendsmessagesgetactivemessagesessionsresponse_unpack(buf []byte) ?CFriendsMessagesGetActiveMessageSessionsResponse { +mut res := CFriendsMessagesGetActiveMessageSessionsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cfriendsmessagesgetactivemessagesessionsresponsefriendmessagesession(cur_buf, tag_wiretype.wire_type)? +res.message_sessions << v +i = ii +} + +2 { +res.has_timestamp = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cfriendsmessagesgetactivemessagesessionsresponse() CFriendsMessagesGetActiveMessageSessionsResponse { +return CFriendsMessagesGetActiveMessageSessionsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cfriendsmessagesgetactivemessagesessionsresponse(o CFriendsMessagesGetActiveMessageSessionsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cfriendsmessagesgetactivemessagesessionsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CFriendsMessagesGetActiveMessageSessionsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cfriendsmessagesgetactivemessagesessionsresponse_unpack(v)? +return i, unpacked +} +pub struct CFriendMessagesSendMessageRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +chat_entry_type int +has_chat_entry_type bool +message string +has_message bool +contains_bbcode bool +has_contains_bbcode bool +echo_to_sender bool +has_echo_to_sender bool +low_priority bool +has_low_priority bool +client_message_id string +has_client_message_id bool +} +pub fn (o &CFriendMessagesSendMessageRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_chat_entry_type { +res << vproto.pack_int32_field(o.chat_entry_type, 2) +} + +if o.has_message { +res << vproto.pack_string_field(o.message, 3) +} + +if o.has_contains_bbcode { +res << vproto.pack_bool_field(o.contains_bbcode, 4) +} + +if o.has_echo_to_sender { +res << vproto.pack_bool_field(o.echo_to_sender, 5) +} + +if o.has_low_priority { +res << vproto.pack_bool_field(o.low_priority, 6) +} + +if o.has_client_message_id { +res << vproto.pack_string_field(o.client_message_id, 8) +} + +return res +} + +pub fn cfriendmessagessendmessagerequest_unpack(buf []byte) ?CFriendMessagesSendMessageRequest { +mut res := CFriendMessagesSendMessageRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_chat_entry_type = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.chat_entry_type = v +i = ii +} + +3 { +res.has_message = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.message = v +i = ii +} + +4 { +res.has_contains_bbcode = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.contains_bbcode = v +i = ii +} + +5 { +res.has_echo_to_sender = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.echo_to_sender = v +i = ii +} + +6 { +res.has_low_priority = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.low_priority = v +i = ii +} + +8 { +res.has_client_message_id = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.client_message_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cfriendmessagessendmessagerequest() CFriendMessagesSendMessageRequest { +return CFriendMessagesSendMessageRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cfriendmessagessendmessagerequest(o CFriendMessagesSendMessageRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cfriendmessagessendmessagerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CFriendMessagesSendMessageRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cfriendmessagessendmessagerequest_unpack(v)? +return i, unpacked +} +pub struct CFriendMessagesSendMessageResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +modified_message string +has_modified_message bool +server_timestamp u32 +has_server_timestamp bool +ordinal u32 +has_ordinal bool +message_without_bb_code string +has_message_without_bb_code bool +} +pub fn (o &CFriendMessagesSendMessageResponse) pack() []byte { +mut res := []byte{} +if o.has_modified_message { +res << vproto.pack_string_field(o.modified_message, 1) +} + +if o.has_server_timestamp { +res << vproto.pack_uint32_field(o.server_timestamp, 2) +} + +if o.has_ordinal { +res << vproto.pack_uint32_field(o.ordinal, 3) +} + +if o.has_message_without_bb_code { +res << vproto.pack_string_field(o.message_without_bb_code, 4) +} + +return res +} + +pub fn cfriendmessagessendmessageresponse_unpack(buf []byte) ?CFriendMessagesSendMessageResponse { +mut res := CFriendMessagesSendMessageResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_modified_message = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.modified_message = v +i = ii +} + +2 { +res.has_server_timestamp = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.server_timestamp = v +i = ii +} + +3 { +res.has_ordinal = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ordinal = v +i = ii +} + +4 { +res.has_message_without_bb_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.message_without_bb_code = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cfriendmessagessendmessageresponse() CFriendMessagesSendMessageResponse { +return CFriendMessagesSendMessageResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cfriendmessagessendmessageresponse(o CFriendMessagesSendMessageResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cfriendmessagessendmessageresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CFriendMessagesSendMessageResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cfriendmessagessendmessageresponse_unpack(v)? +return i, unpacked +} +pub struct CFriendMessagesAckMessageNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid_partner u64 +has_steamid_partner bool +timestamp u32 +has_timestamp bool +} +pub fn (o &CFriendMessagesAckMessageNotification) pack() []byte { +mut res := []byte{} +if o.has_steamid_partner { +res << vproto.pack_64bit_field(o.steamid_partner, 1) +} + +if o.has_timestamp { +res << vproto.pack_uint32_field(o.timestamp, 2) +} + +return res +} + +pub fn cfriendmessagesackmessagenotification_unpack(buf []byte) ?CFriendMessagesAckMessageNotification { +mut res := CFriendMessagesAckMessageNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid_partner = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_partner = v +i = ii +} + +2 { +res.has_timestamp = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cfriendmessagesackmessagenotification() CFriendMessagesAckMessageNotification { +return CFriendMessagesAckMessageNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cfriendmessagesackmessagenotification(o CFriendMessagesAckMessageNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cfriendmessagesackmessagenotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CFriendMessagesAckMessageNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cfriendmessagesackmessagenotification_unpack(v)? +return i, unpacked +} +pub struct CFriendMessagesIsInFriendsUIbetaRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +} +pub fn (o &CFriendMessagesIsInFriendsUIbetaRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +return res +} + +pub fn cfriendmessagesisinfriendsuibetarequest_unpack(buf []byte) ?CFriendMessagesIsInFriendsUIbetaRequest { +mut res := CFriendMessagesIsInFriendsUIbetaRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cfriendmessagesisinfriendsuibetarequest() CFriendMessagesIsInFriendsUIbetaRequest { +return CFriendMessagesIsInFriendsUIbetaRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cfriendmessagesisinfriendsuibetarequest(o CFriendMessagesIsInFriendsUIbetaRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cfriendmessagesisinfriendsuibetarequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CFriendMessagesIsInFriendsUIbetaRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cfriendmessagesisinfriendsuibetarequest_unpack(v)? +return i, unpacked +} +pub struct CFriendMessagesIsInFriendsUIbetaResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +online_in_friendsui bool +has_online_in_friendsui bool +has_used_friendsui bool +has_has_used_friendsui bool +} +pub fn (o &CFriendMessagesIsInFriendsUIbetaResponse) pack() []byte { +mut res := []byte{} +if o.has_online_in_friendsui { +res << vproto.pack_bool_field(o.online_in_friendsui, 1) +} + +if o.has_has_used_friendsui { +res << vproto.pack_bool_field(o.has_used_friendsui, 2) +} + +return res +} + +pub fn cfriendmessagesisinfriendsuibetaresponse_unpack(buf []byte) ?CFriendMessagesIsInFriendsUIbetaResponse { +mut res := CFriendMessagesIsInFriendsUIbetaResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_online_in_friendsui = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.online_in_friendsui = v +i = ii +} + +2 { +res.has_has_used_friendsui = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.has_used_friendsui = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cfriendmessagesisinfriendsuibetaresponse() CFriendMessagesIsInFriendsUIbetaResponse { +return CFriendMessagesIsInFriendsUIbetaResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cfriendmessagesisinfriendsuibetaresponse(o CFriendMessagesIsInFriendsUIbetaResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cfriendmessagesisinfriendsuibetaresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CFriendMessagesIsInFriendsUIbetaResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cfriendmessagesisinfriendsuibetaresponse_unpack(v)? +return i, unpacked +} +pub struct CFriendMessagesIncomingMessageNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid_friend u64 +has_steamid_friend bool +chat_entry_type int +has_chat_entry_type bool +from_limited_account bool +has_from_limited_account bool +message string +has_message bool +rtime32_server_timestamp u32 +has_rtime32_server_timestamp bool +ordinal u32 +has_ordinal bool +local_echo bool +has_local_echo bool +message_no_bbcode string +has_message_no_bbcode bool +low_priority bool +has_low_priority bool +} +pub fn (o &CFriendMessagesIncomingMessageNotification) pack() []byte { +mut res := []byte{} +if o.has_steamid_friend { +res << vproto.pack_64bit_field(o.steamid_friend, 1) +} + +if o.has_chat_entry_type { +res << vproto.pack_int32_field(o.chat_entry_type, 2) +} + +if o.has_from_limited_account { +res << vproto.pack_bool_field(o.from_limited_account, 3) +} + +if o.has_message { +res << vproto.pack_string_field(o.message, 4) +} + +if o.has_rtime32_server_timestamp { +res << vproto.pack_32bit_field(o.rtime32_server_timestamp, 5) +} + +if o.has_ordinal { +res << vproto.pack_uint32_field(o.ordinal, 6) +} + +if o.has_local_echo { +res << vproto.pack_bool_field(o.local_echo, 7) +} + +if o.has_message_no_bbcode { +res << vproto.pack_string_field(o.message_no_bbcode, 8) +} + +if o.has_low_priority { +res << vproto.pack_bool_field(o.low_priority, 9) +} + +return res +} + +pub fn cfriendmessagesincomingmessagenotification_unpack(buf []byte) ?CFriendMessagesIncomingMessageNotification { +mut res := CFriendMessagesIncomingMessageNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid_friend = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_friend = v +i = ii +} + +2 { +res.has_chat_entry_type = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.chat_entry_type = v +i = ii +} + +3 { +res.has_from_limited_account = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.from_limited_account = v +i = ii +} + +4 { +res.has_message = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.message = v +i = ii +} + +5 { +res.has_rtime32_server_timestamp = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.rtime32_server_timestamp = v +i = ii +} + +6 { +res.has_ordinal = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ordinal = v +i = ii +} + +7 { +res.has_local_echo = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.local_echo = v +i = ii +} + +8 { +res.has_message_no_bbcode = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.message_no_bbcode = v +i = ii +} + +9 { +res.has_low_priority = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.low_priority = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cfriendmessagesincomingmessagenotification() CFriendMessagesIncomingMessageNotification { +return CFriendMessagesIncomingMessageNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cfriendmessagesincomingmessagenotification(o CFriendMessagesIncomingMessageNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cfriendmessagesincomingmessagenotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CFriendMessagesIncomingMessageNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cfriendmessagesincomingmessagenotification_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_gamenotifications.steamclient_pb.v b/proto/steammessages_gamenotifications.steamclient_pb.v new file mode 100644 index 0000000..0b64dc0 --- /dev/null +++ b/proto/steammessages_gamenotifications.steamclient_pb.v @@ -0,0 +1,1519 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CGameNotificationsVariable { +mut: +unknown_fields []vproto.UnknownField +pub mut: +key string +has_key bool +value string +has_value bool +} +pub fn (o &CGameNotificationsVariable) pack() []byte { +mut res := []byte{} +if o.has_key { +res << vproto.pack_string_field(o.key, 1) +} + +if o.has_value { +res << vproto.pack_string_field(o.value, 2) +} + +return res +} + +pub fn cgamenotificationsvariable_unpack(buf []byte) ?CGameNotificationsVariable { +mut res := CGameNotificationsVariable{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_key = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.key = v +i = ii +} + +2 { +res.has_value = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.value = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgamenotificationsvariable() CGameNotificationsVariable { +return CGameNotificationsVariable{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgamenotificationsvariable(o CGameNotificationsVariable, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgamenotificationsvariable(buf []byte, tag_wiretype vproto.WireType) ?(int, CGameNotificationsVariable) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgamenotificationsvariable_unpack(v)? +return i, unpacked +} +pub struct CGameNotificationsLocalizedText { +mut: +unknown_fields []vproto.UnknownField +pub mut: +token string +has_token bool +variables []CGameNotificationsVariable +rendered_text string +has_rendered_text bool +} +pub fn (o &CGameNotificationsLocalizedText) pack() []byte { +mut res := []byte{} +if o.has_token { +res << vproto.pack_string_field(o.token, 1) +} + +// [packed=false] +for _, x in o.variables { +res << zzz_vproto_internal_pack_cgamenotificationsvariable(x, 2) +} + +if o.has_rendered_text { +res << vproto.pack_string_field(o.rendered_text, 3) +} + +return res +} + +pub fn cgamenotificationslocalizedtext_unpack(buf []byte) ?CGameNotificationsLocalizedText { +mut res := CGameNotificationsLocalizedText{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_token = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.token = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cgamenotificationsvariable(cur_buf, tag_wiretype.wire_type)? +res.variables << v +i = ii +} + +3 { +res.has_rendered_text = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.rendered_text = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgamenotificationslocalizedtext() CGameNotificationsLocalizedText { +return CGameNotificationsLocalizedText{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgamenotificationslocalizedtext(o CGameNotificationsLocalizedText, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgamenotificationslocalizedtext(buf []byte, tag_wiretype vproto.WireType) ?(int, CGameNotificationsLocalizedText) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgamenotificationslocalizedtext_unpack(v)? +return i, unpacked +} +pub struct CGameNotificationsUserStatus { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +state string +has_state bool +title CGameNotificationsLocalizedText +has_title bool +message CGameNotificationsLocalizedText +has_message bool +} +pub fn (o &CGameNotificationsUserStatus) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_state { +res << vproto.pack_string_field(o.state, 2) +} + +if o.has_title { +res << zzz_vproto_internal_pack_cgamenotificationslocalizedtext(o.title, 3) +} + +if o.has_message { +res << zzz_vproto_internal_pack_cgamenotificationslocalizedtext(o.message, 4) +} + +return res +} + +pub fn cgamenotificationsuserstatus_unpack(buf []byte) ?CGameNotificationsUserStatus { +mut res := CGameNotificationsUserStatus{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_state = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.state = v +i = ii +} + +3 { +res.has_title = true +ii, v := zzz_vproto_internal_unpack_cgamenotificationslocalizedtext(cur_buf, tag_wiretype.wire_type)? +res.title = v +i = ii +} + +4 { +res.has_message = true +ii, v := zzz_vproto_internal_unpack_cgamenotificationslocalizedtext(cur_buf, tag_wiretype.wire_type)? +res.message = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgamenotificationsuserstatus() CGameNotificationsUserStatus { +return CGameNotificationsUserStatus{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgamenotificationsuserstatus(o CGameNotificationsUserStatus, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgamenotificationsuserstatus(buf []byte, tag_wiretype vproto.WireType) ?(int, CGameNotificationsUserStatus) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgamenotificationsuserstatus_unpack(v)? +return i, unpacked +} +pub struct CGameNotificationsCreateSessionRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +context u64 +has_context bool +title CGameNotificationsLocalizedText +has_title bool +users []CGameNotificationsUserStatus +steamid u64 +has_steamid bool +} +pub fn (o &CGameNotificationsCreateSessionRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_context { +res << vproto.pack_uint64_field(o.context, 2) +} + +if o.has_title { +res << zzz_vproto_internal_pack_cgamenotificationslocalizedtext(o.title, 3) +} + +// [packed=false] +for _, x in o.users { +res << zzz_vproto_internal_pack_cgamenotificationsuserstatus(x, 4) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 5) +} + +return res +} + +pub fn cgamenotificationscreatesessionrequest_unpack(buf []byte) ?CGameNotificationsCreateSessionRequest { +mut res := CGameNotificationsCreateSessionRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_context = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.context = v +i = ii +} + +3 { +res.has_title = true +ii, v := zzz_vproto_internal_unpack_cgamenotificationslocalizedtext(cur_buf, tag_wiretype.wire_type)? +res.title = v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cgamenotificationsuserstatus(cur_buf, tag_wiretype.wire_type)? +res.users << v +i = ii +} + +5 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgamenotificationscreatesessionrequest() CGameNotificationsCreateSessionRequest { +return CGameNotificationsCreateSessionRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgamenotificationscreatesessionrequest(o CGameNotificationsCreateSessionRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgamenotificationscreatesessionrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CGameNotificationsCreateSessionRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgamenotificationscreatesessionrequest_unpack(v)? +return i, unpacked +} +pub struct CGameNotificationsCreateSessionResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +sessionid u64 +has_sessionid bool +} +pub fn (o &CGameNotificationsCreateSessionResponse) pack() []byte { +mut res := []byte{} +if o.has_sessionid { +res << vproto.pack_uint64_field(o.sessionid, 1) +} + +return res +} + +pub fn cgamenotificationscreatesessionresponse_unpack(buf []byte) ?CGameNotificationsCreateSessionResponse { +mut res := CGameNotificationsCreateSessionResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_sessionid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.sessionid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgamenotificationscreatesessionresponse() CGameNotificationsCreateSessionResponse { +return CGameNotificationsCreateSessionResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgamenotificationscreatesessionresponse(o CGameNotificationsCreateSessionResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgamenotificationscreatesessionresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CGameNotificationsCreateSessionResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgamenotificationscreatesessionresponse_unpack(v)? +return i, unpacked +} +pub struct CGameNotificationsDeleteSessionRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +sessionid u64 +has_sessionid bool +appid u32 +has_appid bool +steamid u64 +has_steamid bool +} +pub fn (o &CGameNotificationsDeleteSessionRequest) pack() []byte { +mut res := []byte{} +if o.has_sessionid { +res << vproto.pack_uint64_field(o.sessionid, 1) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 2) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 3) +} + +return res +} + +pub fn cgamenotificationsdeletesessionrequest_unpack(buf []byte) ?CGameNotificationsDeleteSessionRequest { +mut res := CGameNotificationsDeleteSessionRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_sessionid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.sessionid = v +i = ii +} + +2 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +3 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgamenotificationsdeletesessionrequest() CGameNotificationsDeleteSessionRequest { +return CGameNotificationsDeleteSessionRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgamenotificationsdeletesessionrequest(o CGameNotificationsDeleteSessionRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgamenotificationsdeletesessionrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CGameNotificationsDeleteSessionRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgamenotificationsdeletesessionrequest_unpack(v)? +return i, unpacked +} +pub struct CGameNotificationsDeleteSessionResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CGameNotificationsDeleteSessionResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cgamenotificationsdeletesessionresponse_unpack(buf []byte) ?CGameNotificationsDeleteSessionResponse { +res := CGameNotificationsDeleteSessionResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgamenotificationsdeletesessionresponse() CGameNotificationsDeleteSessionResponse { +return CGameNotificationsDeleteSessionResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgamenotificationsdeletesessionresponse(o CGameNotificationsDeleteSessionResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgamenotificationsdeletesessionresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CGameNotificationsDeleteSessionResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgamenotificationsdeletesessionresponse_unpack(v)? +return i, unpacked +} +pub struct CGameNotificationsUpdateSessionRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +sessionid u64 +has_sessionid bool +appid u32 +has_appid bool +title CGameNotificationsLocalizedText +has_title bool +users []CGameNotificationsUserStatus +steamid u64 +has_steamid bool +} +pub fn (o &CGameNotificationsUpdateSessionRequest) pack() []byte { +mut res := []byte{} +if o.has_sessionid { +res << vproto.pack_uint64_field(o.sessionid, 1) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 2) +} + +if o.has_title { +res << zzz_vproto_internal_pack_cgamenotificationslocalizedtext(o.title, 3) +} + +// [packed=false] +for _, x in o.users { +res << zzz_vproto_internal_pack_cgamenotificationsuserstatus(x, 4) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 6) +} + +return res +} + +pub fn cgamenotificationsupdatesessionrequest_unpack(buf []byte) ?CGameNotificationsUpdateSessionRequest { +mut res := CGameNotificationsUpdateSessionRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_sessionid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.sessionid = v +i = ii +} + +2 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +3 { +res.has_title = true +ii, v := zzz_vproto_internal_unpack_cgamenotificationslocalizedtext(cur_buf, tag_wiretype.wire_type)? +res.title = v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cgamenotificationsuserstatus(cur_buf, tag_wiretype.wire_type)? +res.users << v +i = ii +} + +6 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgamenotificationsupdatesessionrequest() CGameNotificationsUpdateSessionRequest { +return CGameNotificationsUpdateSessionRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgamenotificationsupdatesessionrequest(o CGameNotificationsUpdateSessionRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgamenotificationsupdatesessionrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CGameNotificationsUpdateSessionRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgamenotificationsupdatesessionrequest_unpack(v)? +return i, unpacked +} +pub struct CGameNotificationsUpdateSessionResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CGameNotificationsUpdateSessionResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cgamenotificationsupdatesessionresponse_unpack(buf []byte) ?CGameNotificationsUpdateSessionResponse { +res := CGameNotificationsUpdateSessionResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgamenotificationsupdatesessionresponse() CGameNotificationsUpdateSessionResponse { +return CGameNotificationsUpdateSessionResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgamenotificationsupdatesessionresponse(o CGameNotificationsUpdateSessionResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgamenotificationsupdatesessionresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CGameNotificationsUpdateSessionResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgamenotificationsupdatesessionresponse_unpack(v)? +return i, unpacked +} +pub struct CGameNotificationsEnumerateSessionsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +include_all_user_messages bool +has_include_all_user_messages bool +include_auth_user_message bool +has_include_auth_user_message bool +language string +has_language bool +} +pub fn (o &CGameNotificationsEnumerateSessionsRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_include_all_user_messages { +res << vproto.pack_bool_field(o.include_all_user_messages, 3) +} + +if o.has_include_auth_user_message { +res << vproto.pack_bool_field(o.include_auth_user_message, 4) +} + +if o.has_language { +res << vproto.pack_string_field(o.language, 5) +} + +return res +} + +pub fn cgamenotificationsenumeratesessionsrequest_unpack(buf []byte) ?CGameNotificationsEnumerateSessionsRequest { +mut res := CGameNotificationsEnumerateSessionsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +3 { +res.has_include_all_user_messages = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.include_all_user_messages = v +i = ii +} + +4 { +res.has_include_auth_user_message = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.include_auth_user_message = v +i = ii +} + +5 { +res.has_language = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgamenotificationsenumeratesessionsrequest() CGameNotificationsEnumerateSessionsRequest { +return CGameNotificationsEnumerateSessionsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgamenotificationsenumeratesessionsrequest(o CGameNotificationsEnumerateSessionsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgamenotificationsenumeratesessionsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CGameNotificationsEnumerateSessionsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgamenotificationsenumeratesessionsrequest_unpack(v)? +return i, unpacked +} +pub struct CGameNotificationsSession { +mut: +unknown_fields []vproto.UnknownField +pub mut: +sessionid u64 +has_sessionid bool +appid u64 +has_appid bool +context u64 +has_context bool +title CGameNotificationsLocalizedText +has_title bool +time_created u32 +has_time_created bool +time_updated u32 +has_time_updated bool +user_status []CGameNotificationsUserStatus +} +pub fn (o &CGameNotificationsSession) pack() []byte { +mut res := []byte{} +if o.has_sessionid { +res << vproto.pack_uint64_field(o.sessionid, 1) +} + +if o.has_appid { +res << vproto.pack_uint64_field(o.appid, 2) +} + +if o.has_context { +res << vproto.pack_uint64_field(o.context, 3) +} + +if o.has_title { +res << zzz_vproto_internal_pack_cgamenotificationslocalizedtext(o.title, 4) +} + +if o.has_time_created { +res << vproto.pack_uint32_field(o.time_created, 5) +} + +if o.has_time_updated { +res << vproto.pack_uint32_field(o.time_updated, 6) +} + +// [packed=false] +for _, x in o.user_status { +res << zzz_vproto_internal_pack_cgamenotificationsuserstatus(x, 7) +} + +return res +} + +pub fn cgamenotificationssession_unpack(buf []byte) ?CGameNotificationsSession { +mut res := CGameNotificationsSession{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_sessionid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.sessionid = v +i = ii +} + +2 { +res.has_appid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +3 { +res.has_context = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.context = v +i = ii +} + +4 { +res.has_title = true +ii, v := zzz_vproto_internal_unpack_cgamenotificationslocalizedtext(cur_buf, tag_wiretype.wire_type)? +res.title = v +i = ii +} + +5 { +res.has_time_created = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_created = v +i = ii +} + +6 { +res.has_time_updated = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_updated = v +i = ii +} + +7 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cgamenotificationsuserstatus(cur_buf, tag_wiretype.wire_type)? +res.user_status << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgamenotificationssession() CGameNotificationsSession { +return CGameNotificationsSession{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgamenotificationssession(o CGameNotificationsSession, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgamenotificationssession(buf []byte, tag_wiretype vproto.WireType) ?(int, CGameNotificationsSession) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgamenotificationssession_unpack(v)? +return i, unpacked +} +pub struct CGameNotificationsEnumerateSessionsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +sessions []CGameNotificationsSession +} +pub fn (o &CGameNotificationsEnumerateSessionsResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.sessions { +res << zzz_vproto_internal_pack_cgamenotificationssession(x, 1) +} + +return res +} + +pub fn cgamenotificationsenumeratesessionsresponse_unpack(buf []byte) ?CGameNotificationsEnumerateSessionsResponse { +mut res := CGameNotificationsEnumerateSessionsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cgamenotificationssession(cur_buf, tag_wiretype.wire_type)? +res.sessions << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgamenotificationsenumeratesessionsresponse() CGameNotificationsEnumerateSessionsResponse { +return CGameNotificationsEnumerateSessionsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgamenotificationsenumeratesessionsresponse(o CGameNotificationsEnumerateSessionsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgamenotificationsenumeratesessionsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CGameNotificationsEnumerateSessionsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgamenotificationsenumeratesessionsresponse_unpack(v)? +return i, unpacked +} +pub struct CGameNotificationsGetSessionDetailsRequestRequestedSession { +mut: +unknown_fields []vproto.UnknownField +pub mut: +sessionid u64 +has_sessionid bool +include_auth_user_message bool +has_include_auth_user_message bool +} +pub fn (o &CGameNotificationsGetSessionDetailsRequestRequestedSession) pack() []byte { +mut res := []byte{} +if o.has_sessionid { +res << vproto.pack_uint64_field(o.sessionid, 1) +} + +if o.has_include_auth_user_message { +res << vproto.pack_bool_field(o.include_auth_user_message, 3) +} + +return res +} + +pub fn cgamenotificationsgetsessiondetailsrequestrequestedsession_unpack(buf []byte) ?CGameNotificationsGetSessionDetailsRequestRequestedSession { +mut res := CGameNotificationsGetSessionDetailsRequestRequestedSession{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_sessionid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.sessionid = v +i = ii +} + +3 { +res.has_include_auth_user_message = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.include_auth_user_message = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgamenotificationsgetsessiondetailsrequestrequestedsession() CGameNotificationsGetSessionDetailsRequestRequestedSession { +return CGameNotificationsGetSessionDetailsRequestRequestedSession{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgamenotificationsgetsessiondetailsrequestrequestedsession(o CGameNotificationsGetSessionDetailsRequestRequestedSession, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgamenotificationsgetsessiondetailsrequestrequestedsession(buf []byte, tag_wiretype vproto.WireType) ?(int, CGameNotificationsGetSessionDetailsRequestRequestedSession) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgamenotificationsgetsessiondetailsrequestrequestedsession_unpack(v)? +return i, unpacked +} +pub struct CGameNotificationsGetSessionDetailsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +sessions []CGameNotificationsGetSessionDetailsRequestRequestedSession +appid u32 +has_appid bool +language string +has_language bool +} +pub fn (o &CGameNotificationsGetSessionDetailsRequest) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.sessions { +res << zzz_vproto_internal_pack_cgamenotificationsgetsessiondetailsrequestrequestedsession(x, 1) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 2) +} + +if o.has_language { +res << vproto.pack_string_field(o.language, 3) +} + +return res +} + +pub fn cgamenotificationsgetsessiondetailsrequest_unpack(buf []byte) ?CGameNotificationsGetSessionDetailsRequest { +mut res := CGameNotificationsGetSessionDetailsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cgamenotificationsgetsessiondetailsrequestrequestedsession(cur_buf, tag_wiretype.wire_type)? +res.sessions << v +i = ii +} + +2 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +3 { +res.has_language = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgamenotificationsgetsessiondetailsrequest() CGameNotificationsGetSessionDetailsRequest { +return CGameNotificationsGetSessionDetailsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgamenotificationsgetsessiondetailsrequest(o CGameNotificationsGetSessionDetailsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgamenotificationsgetsessiondetailsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CGameNotificationsGetSessionDetailsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgamenotificationsgetsessiondetailsrequest_unpack(v)? +return i, unpacked +} +pub struct CGameNotificationsGetSessionDetailsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +sessions []CGameNotificationsSession +} +pub fn (o &CGameNotificationsGetSessionDetailsResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.sessions { +res << zzz_vproto_internal_pack_cgamenotificationssession(x, 1) +} + +return res +} + +pub fn cgamenotificationsgetsessiondetailsresponse_unpack(buf []byte) ?CGameNotificationsGetSessionDetailsResponse { +mut res := CGameNotificationsGetSessionDetailsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cgamenotificationssession(cur_buf, tag_wiretype.wire_type)? +res.sessions << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgamenotificationsgetsessiondetailsresponse() CGameNotificationsGetSessionDetailsResponse { +return CGameNotificationsGetSessionDetailsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgamenotificationsgetsessiondetailsresponse(o CGameNotificationsGetSessionDetailsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgamenotificationsgetsessiondetailsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CGameNotificationsGetSessionDetailsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgamenotificationsgetsessiondetailsresponse_unpack(v)? +return i, unpacked +} +pub struct GameNotificationSettings { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +allow_notifications bool +has_allow_notifications bool +} +pub fn (o &GameNotificationSettings) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_allow_notifications { +res << vproto.pack_bool_field(o.allow_notifications, 2) +} + +return res +} + +pub fn gamenotificationsettings_unpack(buf []byte) ?GameNotificationSettings { +mut res := GameNotificationSettings{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_allow_notifications = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.allow_notifications = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_gamenotificationsettings() GameNotificationSettings { +return GameNotificationSettings{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_gamenotificationsettings(o GameNotificationSettings, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_gamenotificationsettings(buf []byte, tag_wiretype vproto.WireType) ?(int, GameNotificationSettings) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := gamenotificationsettings_unpack(v)? +return i, unpacked +} +pub struct CGameNotificationsUpdateNotificationSettingsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +game_notification_settings []GameNotificationSettings +} +pub fn (o &CGameNotificationsUpdateNotificationSettingsRequest) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.game_notification_settings { +res << zzz_vproto_internal_pack_gamenotificationsettings(x, 1) +} + +return res +} + +pub fn cgamenotificationsupdatenotificationsettingsrequest_unpack(buf []byte) ?CGameNotificationsUpdateNotificationSettingsRequest { +mut res := CGameNotificationsUpdateNotificationSettingsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_gamenotificationsettings(cur_buf, tag_wiretype.wire_type)? +res.game_notification_settings << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgamenotificationsupdatenotificationsettingsrequest() CGameNotificationsUpdateNotificationSettingsRequest { +return CGameNotificationsUpdateNotificationSettingsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgamenotificationsupdatenotificationsettingsrequest(o CGameNotificationsUpdateNotificationSettingsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgamenotificationsupdatenotificationsettingsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CGameNotificationsUpdateNotificationSettingsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgamenotificationsupdatenotificationsettingsrequest_unpack(v)? +return i, unpacked +} +pub struct CGameNotificationsUpdateNotificationSettingsResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CGameNotificationsUpdateNotificationSettingsResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cgamenotificationsupdatenotificationsettingsresponse_unpack(buf []byte) ?CGameNotificationsUpdateNotificationSettingsResponse { +res := CGameNotificationsUpdateNotificationSettingsResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgamenotificationsupdatenotificationsettingsresponse() CGameNotificationsUpdateNotificationSettingsResponse { +return CGameNotificationsUpdateNotificationSettingsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgamenotificationsupdatenotificationsettingsresponse(o CGameNotificationsUpdateNotificationSettingsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgamenotificationsupdatenotificationsettingsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CGameNotificationsUpdateNotificationSettingsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgamenotificationsupdatenotificationsettingsresponse_unpack(v)? +return i, unpacked +} +pub struct CGameNotificationsOnNotificationsRequestedNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +appid u32 +has_appid bool +} +pub fn (o &CGameNotificationsOnNotificationsRequestedNotification) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 2) +} + +return res +} + +pub fn cgamenotificationsonnotificationsrequestednotification_unpack(buf []byte) ?CGameNotificationsOnNotificationsRequestedNotification { +mut res := CGameNotificationsOnNotificationsRequestedNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgamenotificationsonnotificationsrequestednotification() CGameNotificationsOnNotificationsRequestedNotification { +return CGameNotificationsOnNotificationsRequestedNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgamenotificationsonnotificationsrequestednotification(o CGameNotificationsOnNotificationsRequestedNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgamenotificationsonnotificationsrequestednotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CGameNotificationsOnNotificationsRequestedNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgamenotificationsonnotificationsrequestednotification_unpack(v)? +return i, unpacked +} +pub struct CGameNotificationsOnUserStatusChangedNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +sessionid u64 +has_sessionid bool +appid u32 +has_appid bool +status CGameNotificationsUserStatus +has_status bool +removed bool +has_removed bool +} +pub fn (o &CGameNotificationsOnUserStatusChangedNotification) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_sessionid { +res << vproto.pack_uint64_field(o.sessionid, 2) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 3) +} + +if o.has_status { +res << zzz_vproto_internal_pack_cgamenotificationsuserstatus(o.status, 4) +} + +if o.has_removed { +res << vproto.pack_bool_field(o.removed, 5) +} + +return res +} + +pub fn cgamenotificationsonuserstatuschangednotification_unpack(buf []byte) ?CGameNotificationsOnUserStatusChangedNotification { +mut res := CGameNotificationsOnUserStatusChangedNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_sessionid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.sessionid = v +i = ii +} + +3 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +4 { +res.has_status = true +ii, v := zzz_vproto_internal_unpack_cgamenotificationsuserstatus(cur_buf, tag_wiretype.wire_type)? +res.status = v +i = ii +} + +5 { +res.has_removed = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.removed = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgamenotificationsonuserstatuschangednotification() CGameNotificationsOnUserStatusChangedNotification { +return CGameNotificationsOnUserStatusChangedNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgamenotificationsonuserstatuschangednotification(o CGameNotificationsOnUserStatusChangedNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgamenotificationsonuserstatuschangednotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CGameNotificationsOnUserStatusChangedNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgamenotificationsonuserstatuschangednotification_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_gameservers.steamclient_pb.v b/proto/steammessages_gameservers.steamclient_pb.v new file mode 100644 index 0000000..e6f9424 --- /dev/null +++ b/proto/steammessages_gameservers.steamclient_pb.v @@ -0,0 +1,660 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CGameServersGetServerListRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +filter string +has_filter bool +limit u32 +has_limit bool +} +pub fn (o &CGameServersGetServerListRequest) pack() []byte { +mut res := []byte{} +if o.has_filter { +res << vproto.pack_string_field(o.filter, 1) +} + +if o.has_limit { +res << vproto.pack_uint32_field(o.limit, 2) +} + +return res +} + +pub fn cgameserversgetserverlistrequest_unpack(buf []byte) ?CGameServersGetServerListRequest { +mut res := CGameServersGetServerListRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_filter = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.filter = v +i = ii +} + +2 { +res.has_limit = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.limit = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgameserversgetserverlistrequest() CGameServersGetServerListRequest { +return CGameServersGetServerListRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgameserversgetserverlistrequest(o CGameServersGetServerListRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgameserversgetserverlistrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CGameServersGetServerListRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgameserversgetserverlistrequest_unpack(v)? +return i, unpacked +} +pub struct CGameServersGetServerListResponseServer { +mut: +unknown_fields []vproto.UnknownField +pub mut: +addr string +has_addr bool +gameport u32 +has_gameport bool +specport u32 +has_specport bool +steamid u64 +has_steamid bool +name string +has_name bool +appid u32 +has_appid bool +gamedir string +has_gamedir bool +version string +has_version bool +product string +has_product bool +region int +has_region bool +players int +has_players bool +max_players int +has_max_players bool +bots int +has_bots bool +map string +has_map bool +secure bool +has_secure bool +dedicated bool +has_dedicated bool +os string +has_os bool +gametype string +has_gametype bool +} +pub fn (o &CGameServersGetServerListResponseServer) pack() []byte { +mut res := []byte{} +if o.has_addr { +res << vproto.pack_string_field(o.addr, 1) +} + +if o.has_gameport { +res << vproto.pack_uint32_field(o.gameport, 2) +} + +if o.has_specport { +res << vproto.pack_uint32_field(o.specport, 3) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 4) +} + +if o.has_name { +res << vproto.pack_string_field(o.name, 5) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 6) +} + +if o.has_gamedir { +res << vproto.pack_string_field(o.gamedir, 7) +} + +if o.has_version { +res << vproto.pack_string_field(o.version, 8) +} + +if o.has_product { +res << vproto.pack_string_field(o.product, 9) +} + +if o.has_region { +res << vproto.pack_int32_field(o.region, 10) +} + +if o.has_players { +res << vproto.pack_int32_field(o.players, 11) +} + +if o.has_max_players { +res << vproto.pack_int32_field(o.max_players, 12) +} + +if o.has_bots { +res << vproto.pack_int32_field(o.bots, 13) +} + +if o.has_map { +res << vproto.pack_string_field(o.map, 14) +} + +if o.has_secure { +res << vproto.pack_bool_field(o.secure, 15) +} + +if o.has_dedicated { +res << vproto.pack_bool_field(o.dedicated, 16) +} + +if o.has_os { +res << vproto.pack_string_field(o.os, 17) +} + +if o.has_gametype { +res << vproto.pack_string_field(o.gametype, 18) +} + +return res +} + +pub fn cgameserversgetserverlistresponseserver_unpack(buf []byte) ?CGameServersGetServerListResponseServer { +mut res := CGameServersGetServerListResponseServer{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_addr = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.addr = v +i = ii +} + +2 { +res.has_gameport = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.gameport = v +i = ii +} + +3 { +res.has_specport = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.specport = v +i = ii +} + +4 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +5 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +6 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +7 { +res.has_gamedir = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.gamedir = v +i = ii +} + +8 { +res.has_version = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.version = v +i = ii +} + +9 { +res.has_product = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.product = v +i = ii +} + +10 { +res.has_region = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.region = v +i = ii +} + +11 { +res.has_players = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.players = v +i = ii +} + +12 { +res.has_max_players = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.max_players = v +i = ii +} + +13 { +res.has_bots = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.bots = v +i = ii +} + +14 { +res.has_map = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.map = v +i = ii +} + +15 { +res.has_secure = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.secure = v +i = ii +} + +16 { +res.has_dedicated = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.dedicated = v +i = ii +} + +17 { +res.has_os = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.os = v +i = ii +} + +18 { +res.has_gametype = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.gametype = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgameserversgetserverlistresponseserver() CGameServersGetServerListResponseServer { +return CGameServersGetServerListResponseServer{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgameserversgetserverlistresponseserver(o CGameServersGetServerListResponseServer, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgameserversgetserverlistresponseserver(buf []byte, tag_wiretype vproto.WireType) ?(int, CGameServersGetServerListResponseServer) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgameserversgetserverlistresponseserver_unpack(v)? +return i, unpacked +} +pub struct CGameServersGetServerListResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +servers []CGameServersGetServerListResponseServer +} +pub fn (o &CGameServersGetServerListResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.servers { +res << zzz_vproto_internal_pack_cgameserversgetserverlistresponseserver(x, 1) +} + +return res +} + +pub fn cgameserversgetserverlistresponse_unpack(buf []byte) ?CGameServersGetServerListResponse { +mut res := CGameServersGetServerListResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cgameserversgetserverlistresponseserver(cur_buf, tag_wiretype.wire_type)? +res.servers << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgameserversgetserverlistresponse() CGameServersGetServerListResponse { +return CGameServersGetServerListResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgameserversgetserverlistresponse(o CGameServersGetServerListResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgameserversgetserverlistresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CGameServersGetServerListResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgameserversgetserverlistresponse_unpack(v)? +return i, unpacked +} +pub struct CGameServersGetServerSteamIDsByIPrequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +server_ips []string +} +pub fn (o &CGameServersGetServerSteamIDsByIPrequest) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.server_ips { +res << vproto.pack_string_field(x, 1) +} + +return res +} + +pub fn cgameserversgetserversteamidsbyiprequest_unpack(buf []byte) ?CGameServersGetServerSteamIDsByIPrequest { +mut res := CGameServersGetServerSteamIDsByIPrequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.server_ips << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgameserversgetserversteamidsbyiprequest() CGameServersGetServerSteamIDsByIPrequest { +return CGameServersGetServerSteamIDsByIPrequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgameserversgetserversteamidsbyiprequest(o CGameServersGetServerSteamIDsByIPrequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgameserversgetserversteamidsbyiprequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CGameServersGetServerSteamIDsByIPrequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgameserversgetserversteamidsbyiprequest_unpack(v)? +return i, unpacked +} +pub struct CGameServersIPsWithSteamIDsResponseServer { +mut: +unknown_fields []vproto.UnknownField +pub mut: +addr string +has_addr bool +steamid u64 +has_steamid bool +} +pub fn (o &CGameServersIPsWithSteamIDsResponseServer) pack() []byte { +mut res := []byte{} +if o.has_addr { +res << vproto.pack_string_field(o.addr, 1) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 2) +} + +return res +} + +pub fn cgameserversipswithsteamidsresponseserver_unpack(buf []byte) ?CGameServersIPsWithSteamIDsResponseServer { +mut res := CGameServersIPsWithSteamIDsResponseServer{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_addr = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.addr = v +i = ii +} + +2 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgameserversipswithsteamidsresponseserver() CGameServersIPsWithSteamIDsResponseServer { +return CGameServersIPsWithSteamIDsResponseServer{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgameserversipswithsteamidsresponseserver(o CGameServersIPsWithSteamIDsResponseServer, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgameserversipswithsteamidsresponseserver(buf []byte, tag_wiretype vproto.WireType) ?(int, CGameServersIPsWithSteamIDsResponseServer) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgameserversipswithsteamidsresponseserver_unpack(v)? +return i, unpacked +} +pub struct CGameServersIPsWithSteamIDsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +servers []CGameServersIPsWithSteamIDsResponseServer +} +pub fn (o &CGameServersIPsWithSteamIDsResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.servers { +res << zzz_vproto_internal_pack_cgameserversipswithsteamidsresponseserver(x, 1) +} + +return res +} + +pub fn cgameserversipswithsteamidsresponse_unpack(buf []byte) ?CGameServersIPsWithSteamIDsResponse { +mut res := CGameServersIPsWithSteamIDsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cgameserversipswithsteamidsresponseserver(cur_buf, tag_wiretype.wire_type)? +res.servers << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgameserversipswithsteamidsresponse() CGameServersIPsWithSteamIDsResponse { +return CGameServersIPsWithSteamIDsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgameserversipswithsteamidsresponse(o CGameServersIPsWithSteamIDsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgameserversipswithsteamidsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CGameServersIPsWithSteamIDsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgameserversipswithsteamidsresponse_unpack(v)? +return i, unpacked +} +pub struct CGameServersGetServerIPsBySteamIDrequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +server_steamids []u64 +} +pub fn (o &CGameServersGetServerIPsBySteamIDrequest) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.server_steamids { +res << vproto.pack_64bit_field(x, 1) +} + +return res +} + +pub fn cgameserversgetserveripsbysteamidrequest_unpack(buf []byte) ?CGameServersGetServerIPsBySteamIDrequest { +mut res := CGameServersGetServerIPsBySteamIDrequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.server_steamids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgameserversgetserveripsbysteamidrequest() CGameServersGetServerIPsBySteamIDrequest { +return CGameServersGetServerIPsBySteamIDrequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgameserversgetserveripsbysteamidrequest(o CGameServersGetServerIPsBySteamIDrequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgameserversgetserveripsbysteamidrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CGameServersGetServerIPsBySteamIDrequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgameserversgetserveripsbysteamidrequest_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_hiddevices_pb.v b/proto/steammessages_hiddevices_pb.v new file mode 100644 index 0000000..0bbc2a4 --- /dev/null +++ b/proto/steammessages_hiddevices_pb.v @@ -0,0 +1,1670 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +[_allow_multiple_values] +enum EHiddeviceLocation { +k_edevicelocationlocal = 0 +k_edevicelocationremote = 2 +k_edevicelocationany = 3 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_ehiddevicelocation(e EHiddeviceLocation, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_ehiddevicelocation(buf []byte, tag_wiretype vproto.WireType) ?(int, EHiddeviceLocation) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EHiddeviceLocation(v) +} +[_allow_multiple_values] +enum EHiddeviceDisconnectMethod { +k_edevicedisconnectmethodunknown = 0 +k_edevicedisconnectmethodbluetooth = 1 +k_edevicedisconnectmethodfeaturereport = 2 +k_edevicedisconnectmethodoutputreport = 3 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_ehiddevicedisconnectmethod(e EHiddeviceDisconnectMethod, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_ehiddevicedisconnectmethod(buf []byte, tag_wiretype vproto.WireType) ?(int, EHiddeviceDisconnectMethod) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EHiddeviceDisconnectMethod(v) +} +pub struct CHiddeviceInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +location EHiddeviceLocation +has_location bool +path string +has_path bool +vendor_id u32 +has_vendor_id bool +product_id u32 +has_product_id bool +serial_number string +has_serial_number bool +release_number u32 +has_release_number bool +manufacturer_string string +has_manufacturer_string bool +product_string string +has_product_string bool +usage_page u32 +has_usage_page bool +usage u32 +has_usage bool +interface_number int +has_interface_number bool +ostype int +has_ostype bool +is_generic_gamepad bool +has_is_generic_gamepad bool +is_generic_joystick bool +has_is_generic_joystick bool +caps_bits u32 +has_caps_bits bool +session_id u32 +has_session_id bool +econtrollertype u32 +has_econtrollertype bool +is_xinput_device bool +has_is_xinput_device bool +} +pub fn (o &CHiddeviceInfo) pack() []byte { +mut res := []byte{} +if o.has_location { +res << zzz_vproto_internal_pack_ehiddevicelocation(o.location, 1) +} + +if o.has_path { +res << vproto.pack_string_field(o.path, 2) +} + +if o.has_vendor_id { +res << vproto.pack_uint32_field(o.vendor_id, 3) +} + +if o.has_product_id { +res << vproto.pack_uint32_field(o.product_id, 4) +} + +if o.has_serial_number { +res << vproto.pack_string_field(o.serial_number, 5) +} + +if o.has_release_number { +res << vproto.pack_uint32_field(o.release_number, 6) +} + +if o.has_manufacturer_string { +res << vproto.pack_string_field(o.manufacturer_string, 7) +} + +if o.has_product_string { +res << vproto.pack_string_field(o.product_string, 8) +} + +if o.has_usage_page { +res << vproto.pack_uint32_field(o.usage_page, 9) +} + +if o.has_usage { +res << vproto.pack_uint32_field(o.usage, 10) +} + +if o.has_interface_number { +res << vproto.pack_int32_field(o.interface_number, 11) +} + +if o.has_ostype { +res << vproto.pack_int32_field(o.ostype, 12) +} + +if o.has_is_generic_gamepad { +res << vproto.pack_bool_field(o.is_generic_gamepad, 13) +} + +if o.has_is_generic_joystick { +res << vproto.pack_bool_field(o.is_generic_joystick, 14) +} + +if o.has_caps_bits { +res << vproto.pack_uint32_field(o.caps_bits, 15) +} + +if o.has_session_id { +res << vproto.pack_uint32_field(o.session_id, 16) +} + +if o.has_econtrollertype { +res << vproto.pack_uint32_field(o.econtrollertype, 17) +} + +if o.has_is_xinput_device { +res << vproto.pack_bool_field(o.is_xinput_device, 18) +} + +return res +} + +pub fn chiddeviceinfo_unpack(buf []byte) ?CHiddeviceInfo { +mut res := CHiddeviceInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_location = true +ii, v := zzz_vproto_internal_unpack_ehiddevicelocation(cur_buf, tag_wiretype.wire_type)? +res.location = v +i = ii +} + +2 { +res.has_path = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.path = v +i = ii +} + +3 { +res.has_vendor_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.vendor_id = v +i = ii +} + +4 { +res.has_product_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.product_id = v +i = ii +} + +5 { +res.has_serial_number = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.serial_number = v +i = ii +} + +6 { +res.has_release_number = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.release_number = v +i = ii +} + +7 { +res.has_manufacturer_string = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.manufacturer_string = v +i = ii +} + +8 { +res.has_product_string = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.product_string = v +i = ii +} + +9 { +res.has_usage_page = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.usage_page = v +i = ii +} + +10 { +res.has_usage = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.usage = v +i = ii +} + +11 { +res.has_interface_number = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.interface_number = v +i = ii +} + +12 { +res.has_ostype = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.ostype = v +i = ii +} + +13 { +res.has_is_generic_gamepad = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_generic_gamepad = v +i = ii +} + +14 { +res.has_is_generic_joystick = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_generic_joystick = v +i = ii +} + +15 { +res.has_caps_bits = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.caps_bits = v +i = ii +} + +16 { +res.has_session_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.session_id = v +i = ii +} + +17 { +res.has_econtrollertype = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.econtrollertype = v +i = ii +} + +18 { +res.has_is_xinput_device = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_xinput_device = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_chiddeviceinfo() CHiddeviceInfo { +return CHiddeviceInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_chiddeviceinfo(o CHiddeviceInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_chiddeviceinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CHiddeviceInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := chiddeviceinfo_unpack(v)? +return i, unpacked +} +pub struct CHiddeviceInputReport { +mut: +unknown_fields []vproto.UnknownField +pub mut: +full_report []byte +has_full_report bool +delta_report []byte +has_delta_report bool +delta_report_size u32 +has_delta_report_size bool +delta_report_crc u32 +has_delta_report_crc bool +} +pub fn (o &CHiddeviceInputReport) pack() []byte { +mut res := []byte{} +if o.has_full_report { +res << vproto.pack_bytes_field(o.full_report, 1) +} + +if o.has_delta_report { +res << vproto.pack_bytes_field(o.delta_report, 2) +} + +if o.has_delta_report_size { +res << vproto.pack_uint32_field(o.delta_report_size, 3) +} + +if o.has_delta_report_crc { +res << vproto.pack_uint32_field(o.delta_report_crc, 4) +} + +return res +} + +pub fn chiddeviceinputreport_unpack(buf []byte) ?CHiddeviceInputReport { +mut res := CHiddeviceInputReport{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_full_report = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.full_report = v +i = ii +} + +2 { +res.has_delta_report = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.delta_report = v +i = ii +} + +3 { +res.has_delta_report_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.delta_report_size = v +i = ii +} + +4 { +res.has_delta_report_crc = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.delta_report_crc = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_chiddeviceinputreport() CHiddeviceInputReport { +return CHiddeviceInputReport{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_chiddeviceinputreport(o CHiddeviceInputReport, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_chiddeviceinputreport(buf []byte, tag_wiretype vproto.WireType) ?(int, CHiddeviceInputReport) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := chiddeviceinputreport_unpack(v)? +return i, unpacked +} +pub struct CHidmessageToRemoteDeviceOpen { +mut: +unknown_fields []vproto.UnknownField +pub mut: +info CHiddeviceInfo +has_info bool +} +pub fn (o &CHidmessageToRemoteDeviceOpen) pack() []byte { +mut res := []byte{} +if o.has_info { +res << zzz_vproto_internal_pack_chiddeviceinfo(o.info, 1) +} + +return res +} + +pub fn chidmessagetoremotedeviceopen_unpack(buf []byte) ?CHidmessageToRemoteDeviceOpen { +mut res := CHidmessageToRemoteDeviceOpen{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_info = true +ii, v := zzz_vproto_internal_unpack_chiddeviceinfo(cur_buf, tag_wiretype.wire_type)? +res.info = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_chidmessagetoremotedeviceopen() CHidmessageToRemoteDeviceOpen { +return CHidmessageToRemoteDeviceOpen{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_chidmessagetoremotedeviceopen(o CHidmessageToRemoteDeviceOpen, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_chidmessagetoremotedeviceopen(buf []byte, tag_wiretype vproto.WireType) ?(int, CHidmessageToRemoteDeviceOpen) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := chidmessagetoremotedeviceopen_unpack(v)? +return i, unpacked +} +pub struct CHidmessageToRemoteDeviceClose { +mut: +unknown_fields []vproto.UnknownField +pub mut: +device u32 +has_device bool +} +pub fn (o &CHidmessageToRemoteDeviceClose) pack() []byte { +mut res := []byte{} +if o.has_device { +res << vproto.pack_uint32_field(o.device, 1) +} + +return res +} + +pub fn chidmessagetoremotedeviceclose_unpack(buf []byte) ?CHidmessageToRemoteDeviceClose { +mut res := CHidmessageToRemoteDeviceClose{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_device = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.device = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_chidmessagetoremotedeviceclose() CHidmessageToRemoteDeviceClose { +return CHidmessageToRemoteDeviceClose{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_chidmessagetoremotedeviceclose(o CHidmessageToRemoteDeviceClose, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_chidmessagetoremotedeviceclose(buf []byte, tag_wiretype vproto.WireType) ?(int, CHidmessageToRemoteDeviceClose) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := chidmessagetoremotedeviceclose_unpack(v)? +return i, unpacked +} +pub struct CHidmessageToRemoteDeviceWrite { +mut: +unknown_fields []vproto.UnknownField +pub mut: +device u32 +has_device bool +data []byte +has_data bool +} +pub fn (o &CHidmessageToRemoteDeviceWrite) pack() []byte { +mut res := []byte{} +if o.has_device { +res << vproto.pack_uint32_field(o.device, 1) +} + +if o.has_data { +res << vproto.pack_bytes_field(o.data, 2) +} + +return res +} + +pub fn chidmessagetoremotedevicewrite_unpack(buf []byte) ?CHidmessageToRemoteDeviceWrite { +mut res := CHidmessageToRemoteDeviceWrite{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_device = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.device = v +i = ii +} + +2 { +res.has_data = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.data = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_chidmessagetoremotedevicewrite() CHidmessageToRemoteDeviceWrite { +return CHidmessageToRemoteDeviceWrite{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_chidmessagetoremotedevicewrite(o CHidmessageToRemoteDeviceWrite, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_chidmessagetoremotedevicewrite(buf []byte, tag_wiretype vproto.WireType) ?(int, CHidmessageToRemoteDeviceWrite) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := chidmessagetoremotedevicewrite_unpack(v)? +return i, unpacked +} +pub struct CHidmessageToRemoteDeviceRead { +mut: +unknown_fields []vproto.UnknownField +pub mut: +device u32 +has_device bool +length u32 +has_length bool +timeout_ms int +has_timeout_ms bool +} +pub fn (o &CHidmessageToRemoteDeviceRead) pack() []byte { +mut res := []byte{} +if o.has_device { +res << vproto.pack_uint32_field(o.device, 1) +} + +if o.has_length { +res << vproto.pack_uint32_field(o.length, 2) +} + +if o.has_timeout_ms { +res << vproto.pack_int32_field(o.timeout_ms, 3) +} + +return res +} + +pub fn chidmessagetoremotedeviceread_unpack(buf []byte) ?CHidmessageToRemoteDeviceRead { +mut res := CHidmessageToRemoteDeviceRead{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_device = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.device = v +i = ii +} + +2 { +res.has_length = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.length = v +i = ii +} + +3 { +res.has_timeout_ms = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.timeout_ms = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_chidmessagetoremotedeviceread() CHidmessageToRemoteDeviceRead { +return CHidmessageToRemoteDeviceRead{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_chidmessagetoremotedeviceread(o CHidmessageToRemoteDeviceRead, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_chidmessagetoremotedeviceread(buf []byte, tag_wiretype vproto.WireType) ?(int, CHidmessageToRemoteDeviceRead) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := chidmessagetoremotedeviceread_unpack(v)? +return i, unpacked +} +pub struct CHidmessageToRemoteDeviceSendFeatureReport { +mut: +unknown_fields []vproto.UnknownField +pub mut: +device u32 +has_device bool +data []byte +has_data bool +} +pub fn (o &CHidmessageToRemoteDeviceSendFeatureReport) pack() []byte { +mut res := []byte{} +if o.has_device { +res << vproto.pack_uint32_field(o.device, 1) +} + +if o.has_data { +res << vproto.pack_bytes_field(o.data, 2) +} + +return res +} + +pub fn chidmessagetoremotedevicesendfeaturereport_unpack(buf []byte) ?CHidmessageToRemoteDeviceSendFeatureReport { +mut res := CHidmessageToRemoteDeviceSendFeatureReport{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_device = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.device = v +i = ii +} + +2 { +res.has_data = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.data = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_chidmessagetoremotedevicesendfeaturereport() CHidmessageToRemoteDeviceSendFeatureReport { +return CHidmessageToRemoteDeviceSendFeatureReport{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_chidmessagetoremotedevicesendfeaturereport(o CHidmessageToRemoteDeviceSendFeatureReport, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_chidmessagetoremotedevicesendfeaturereport(buf []byte, tag_wiretype vproto.WireType) ?(int, CHidmessageToRemoteDeviceSendFeatureReport) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := chidmessagetoremotedevicesendfeaturereport_unpack(v)? +return i, unpacked +} +pub struct CHidmessageToRemoteDeviceGetFeatureReport { +mut: +unknown_fields []vproto.UnknownField +pub mut: +device u32 +has_device bool +report_number []byte +has_report_number bool +length u32 +has_length bool +} +pub fn (o &CHidmessageToRemoteDeviceGetFeatureReport) pack() []byte { +mut res := []byte{} +if o.has_device { +res << vproto.pack_uint32_field(o.device, 1) +} + +if o.has_report_number { +res << vproto.pack_bytes_field(o.report_number, 2) +} + +if o.has_length { +res << vproto.pack_uint32_field(o.length, 3) +} + +return res +} + +pub fn chidmessagetoremotedevicegetfeaturereport_unpack(buf []byte) ?CHidmessageToRemoteDeviceGetFeatureReport { +mut res := CHidmessageToRemoteDeviceGetFeatureReport{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_device = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.device = v +i = ii +} + +2 { +res.has_report_number = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.report_number = v +i = ii +} + +3 { +res.has_length = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.length = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_chidmessagetoremotedevicegetfeaturereport() CHidmessageToRemoteDeviceGetFeatureReport { +return CHidmessageToRemoteDeviceGetFeatureReport{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_chidmessagetoremotedevicegetfeaturereport(o CHidmessageToRemoteDeviceGetFeatureReport, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_chidmessagetoremotedevicegetfeaturereport(buf []byte, tag_wiretype vproto.WireType) ?(int, CHidmessageToRemoteDeviceGetFeatureReport) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := chidmessagetoremotedevicegetfeaturereport_unpack(v)? +return i, unpacked +} +pub struct CHidmessageToRemoteDeviceGetVendorString { +mut: +unknown_fields []vproto.UnknownField +pub mut: +device u32 +has_device bool +} +pub fn (o &CHidmessageToRemoteDeviceGetVendorString) pack() []byte { +mut res := []byte{} +if o.has_device { +res << vproto.pack_uint32_field(o.device, 1) +} + +return res +} + +pub fn chidmessagetoremotedevicegetvendorstring_unpack(buf []byte) ?CHidmessageToRemoteDeviceGetVendorString { +mut res := CHidmessageToRemoteDeviceGetVendorString{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_device = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.device = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_chidmessagetoremotedevicegetvendorstring() CHidmessageToRemoteDeviceGetVendorString { +return CHidmessageToRemoteDeviceGetVendorString{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_chidmessagetoremotedevicegetvendorstring(o CHidmessageToRemoteDeviceGetVendorString, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_chidmessagetoremotedevicegetvendorstring(buf []byte, tag_wiretype vproto.WireType) ?(int, CHidmessageToRemoteDeviceGetVendorString) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := chidmessagetoremotedevicegetvendorstring_unpack(v)? +return i, unpacked +} +pub struct CHidmessageToRemoteDeviceGetProductString { +mut: +unknown_fields []vproto.UnknownField +pub mut: +device u32 +has_device bool +} +pub fn (o &CHidmessageToRemoteDeviceGetProductString) pack() []byte { +mut res := []byte{} +if o.has_device { +res << vproto.pack_uint32_field(o.device, 1) +} + +return res +} + +pub fn chidmessagetoremotedevicegetproductstring_unpack(buf []byte) ?CHidmessageToRemoteDeviceGetProductString { +mut res := CHidmessageToRemoteDeviceGetProductString{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_device = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.device = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_chidmessagetoremotedevicegetproductstring() CHidmessageToRemoteDeviceGetProductString { +return CHidmessageToRemoteDeviceGetProductString{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_chidmessagetoremotedevicegetproductstring(o CHidmessageToRemoteDeviceGetProductString, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_chidmessagetoremotedevicegetproductstring(buf []byte, tag_wiretype vproto.WireType) ?(int, CHidmessageToRemoteDeviceGetProductString) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := chidmessagetoremotedevicegetproductstring_unpack(v)? +return i, unpacked +} +pub struct CHidmessageToRemoteDeviceGetSerialNumberString { +mut: +unknown_fields []vproto.UnknownField +pub mut: +device u32 +has_device bool +} +pub fn (o &CHidmessageToRemoteDeviceGetSerialNumberString) pack() []byte { +mut res := []byte{} +if o.has_device { +res << vproto.pack_uint32_field(o.device, 1) +} + +return res +} + +pub fn chidmessagetoremotedevicegetserialnumberstring_unpack(buf []byte) ?CHidmessageToRemoteDeviceGetSerialNumberString { +mut res := CHidmessageToRemoteDeviceGetSerialNumberString{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_device = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.device = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_chidmessagetoremotedevicegetserialnumberstring() CHidmessageToRemoteDeviceGetSerialNumberString { +return CHidmessageToRemoteDeviceGetSerialNumberString{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_chidmessagetoremotedevicegetserialnumberstring(o CHidmessageToRemoteDeviceGetSerialNumberString, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_chidmessagetoremotedevicegetserialnumberstring(buf []byte, tag_wiretype vproto.WireType) ?(int, CHidmessageToRemoteDeviceGetSerialNumberString) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := chidmessagetoremotedevicegetserialnumberstring_unpack(v)? +return i, unpacked +} +pub struct CHidmessageToRemoteDeviceStartInputReports { +mut: +unknown_fields []vproto.UnknownField +pub mut: +device u32 +has_device bool +length u32 +has_length bool +} +pub fn (o &CHidmessageToRemoteDeviceStartInputReports) pack() []byte { +mut res := []byte{} +if o.has_device { +res << vproto.pack_uint32_field(o.device, 1) +} + +if o.has_length { +res << vproto.pack_uint32_field(o.length, 2) +} + +return res +} + +pub fn chidmessagetoremotedevicestartinputreports_unpack(buf []byte) ?CHidmessageToRemoteDeviceStartInputReports { +mut res := CHidmessageToRemoteDeviceStartInputReports{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_device = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.device = v +i = ii +} + +2 { +res.has_length = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.length = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_chidmessagetoremotedevicestartinputreports() CHidmessageToRemoteDeviceStartInputReports { +return CHidmessageToRemoteDeviceStartInputReports{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_chidmessagetoremotedevicestartinputreports(o CHidmessageToRemoteDeviceStartInputReports, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_chidmessagetoremotedevicestartinputreports(buf []byte, tag_wiretype vproto.WireType) ?(int, CHidmessageToRemoteDeviceStartInputReports) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := chidmessagetoremotedevicestartinputreports_unpack(v)? +return i, unpacked +} +pub struct CHidmessageToRemoteDeviceRequestFullReport { +mut: +unknown_fields []vproto.UnknownField +pub mut: +device u32 +has_device bool +} +pub fn (o &CHidmessageToRemoteDeviceRequestFullReport) pack() []byte { +mut res := []byte{} +if o.has_device { +res << vproto.pack_uint32_field(o.device, 1) +} + +return res +} + +pub fn chidmessagetoremotedevicerequestfullreport_unpack(buf []byte) ?CHidmessageToRemoteDeviceRequestFullReport { +mut res := CHidmessageToRemoteDeviceRequestFullReport{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_device = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.device = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_chidmessagetoremotedevicerequestfullreport() CHidmessageToRemoteDeviceRequestFullReport { +return CHidmessageToRemoteDeviceRequestFullReport{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_chidmessagetoremotedevicerequestfullreport(o CHidmessageToRemoteDeviceRequestFullReport, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_chidmessagetoremotedevicerequestfullreport(buf []byte, tag_wiretype vproto.WireType) ?(int, CHidmessageToRemoteDeviceRequestFullReport) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := chidmessagetoremotedevicerequestfullreport_unpack(v)? +return i, unpacked +} +pub struct CHidmessageToRemoteDeviceDisconnect { +mut: +unknown_fields []vproto.UnknownField +pub mut: +device u32 +has_device bool +disconnectmethod EHiddeviceDisconnectMethod +has_disconnectmethod bool +data []byte +has_data bool +} +pub fn (o &CHidmessageToRemoteDeviceDisconnect) pack() []byte { +mut res := []byte{} +if o.has_device { +res << vproto.pack_uint32_field(o.device, 1) +} + +if o.has_disconnectmethod { +res << zzz_vproto_internal_pack_ehiddevicedisconnectmethod(o.disconnectmethod, 2) +} + +if o.has_data { +res << vproto.pack_bytes_field(o.data, 3) +} + +return res +} + +pub fn chidmessagetoremotedevicedisconnect_unpack(buf []byte) ?CHidmessageToRemoteDeviceDisconnect { +mut res := CHidmessageToRemoteDeviceDisconnect{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_device = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.device = v +i = ii +} + +2 { +res.has_disconnectmethod = true +ii, v := zzz_vproto_internal_unpack_ehiddevicedisconnectmethod(cur_buf, tag_wiretype.wire_type)? +res.disconnectmethod = v +i = ii +} + +3 { +res.has_data = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.data = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_chidmessagetoremotedevicedisconnect() CHidmessageToRemoteDeviceDisconnect { +return CHidmessageToRemoteDeviceDisconnect{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_chidmessagetoremotedevicedisconnect(o CHidmessageToRemoteDeviceDisconnect, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_chidmessagetoremotedevicedisconnect(buf []byte, tag_wiretype vproto.WireType) ?(int, CHidmessageToRemoteDeviceDisconnect) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := chidmessagetoremotedevicedisconnect_unpack(v)? +return i, unpacked +} +pub struct CHidmessageToRemote { +mut: +unknown_fields []vproto.UnknownField +pub mut: +request_id u32 +has_request_id bool +} +pub fn (o &CHidmessageToRemote) pack() []byte { +mut res := []byte{} +if o.has_request_id { +res << vproto.pack_uint32_field(o.request_id, 1) +} + +return res +} + +pub fn chidmessagetoremote_unpack(buf []byte) ?CHidmessageToRemote { +mut res := CHidmessageToRemote{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_request_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.request_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_chidmessagetoremote() CHidmessageToRemote { +return CHidmessageToRemote{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_chidmessagetoremote(o CHidmessageToRemote, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_chidmessagetoremote(buf []byte, tag_wiretype vproto.WireType) ?(int, CHidmessageToRemote) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := chidmessagetoremote_unpack(v)? +return i, unpacked +} +pub struct CHidmessageFromRemoteUpdateDeviceList { +mut: +unknown_fields []vproto.UnknownField +pub mut: +devices []CHiddeviceInfo +} +pub fn (o &CHidmessageFromRemoteUpdateDeviceList) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.devices { +res << zzz_vproto_internal_pack_chiddeviceinfo(x, 1) +} + +return res +} + +pub fn chidmessagefromremoteupdatedevicelist_unpack(buf []byte) ?CHidmessageFromRemoteUpdateDeviceList { +mut res := CHidmessageFromRemoteUpdateDeviceList{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_chiddeviceinfo(cur_buf, tag_wiretype.wire_type)? +res.devices << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_chidmessagefromremoteupdatedevicelist() CHidmessageFromRemoteUpdateDeviceList { +return CHidmessageFromRemoteUpdateDeviceList{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_chidmessagefromremoteupdatedevicelist(o CHidmessageFromRemoteUpdateDeviceList, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_chidmessagefromremoteupdatedevicelist(buf []byte, tag_wiretype vproto.WireType) ?(int, CHidmessageFromRemoteUpdateDeviceList) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := chidmessagefromremoteupdatedevicelist_unpack(v)? +return i, unpacked +} +pub struct CHidmessageFromRemoteRequestResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +request_id u32 +has_request_id bool +result int +has_result bool +data []byte +has_data bool +} +pub fn (o &CHidmessageFromRemoteRequestResponse) pack() []byte { +mut res := []byte{} +if o.has_request_id { +res << vproto.pack_uint32_field(o.request_id, 1) +} + +if o.has_result { +res << vproto.pack_int32_field(o.result, 2) +} + +if o.has_data { +res << vproto.pack_bytes_field(o.data, 3) +} + +return res +} + +pub fn chidmessagefromremoterequestresponse_unpack(buf []byte) ?CHidmessageFromRemoteRequestResponse { +mut res := CHidmessageFromRemoteRequestResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_request_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.request_id = v +i = ii +} + +2 { +res.has_result = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.result = v +i = ii +} + +3 { +res.has_data = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.data = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_chidmessagefromremoterequestresponse() CHidmessageFromRemoteRequestResponse { +return CHidmessageFromRemoteRequestResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_chidmessagefromremoterequestresponse(o CHidmessageFromRemoteRequestResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_chidmessagefromremoterequestresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CHidmessageFromRemoteRequestResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := chidmessagefromremoterequestresponse_unpack(v)? +return i, unpacked +} +pub struct CHidmessageFromRemoteDeviceInputReportsDeviceInputReport { +mut: +unknown_fields []vproto.UnknownField +pub mut: +device u32 +has_device bool +reports []CHiddeviceInputReport +} +pub fn (o &CHidmessageFromRemoteDeviceInputReportsDeviceInputReport) pack() []byte { +mut res := []byte{} +if o.has_device { +res << vproto.pack_uint32_field(o.device, 1) +} + +// [packed=false] +for _, x in o.reports { +res << zzz_vproto_internal_pack_chiddeviceinputreport(x, 2) +} + +return res +} + +pub fn chidmessagefromremotedeviceinputreportsdeviceinputreport_unpack(buf []byte) ?CHidmessageFromRemoteDeviceInputReportsDeviceInputReport { +mut res := CHidmessageFromRemoteDeviceInputReportsDeviceInputReport{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_device = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.device = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_chiddeviceinputreport(cur_buf, tag_wiretype.wire_type)? +res.reports << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_chidmessagefromremotedeviceinputreportsdeviceinputreport() CHidmessageFromRemoteDeviceInputReportsDeviceInputReport { +return CHidmessageFromRemoteDeviceInputReportsDeviceInputReport{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_chidmessagefromremotedeviceinputreportsdeviceinputreport(o CHidmessageFromRemoteDeviceInputReportsDeviceInputReport, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_chidmessagefromremotedeviceinputreportsdeviceinputreport(buf []byte, tag_wiretype vproto.WireType) ?(int, CHidmessageFromRemoteDeviceInputReportsDeviceInputReport) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := chidmessagefromremotedeviceinputreportsdeviceinputreport_unpack(v)? +return i, unpacked +} +pub struct CHidmessageFromRemoteDeviceInputReports { +mut: +unknown_fields []vproto.UnknownField +pub mut: +device_reports []CHidmessageFromRemoteDeviceInputReportsDeviceInputReport +} +pub fn (o &CHidmessageFromRemoteDeviceInputReports) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.device_reports { +res << zzz_vproto_internal_pack_chidmessagefromremotedeviceinputreportsdeviceinputreport(x, 1) +} + +return res +} + +pub fn chidmessagefromremotedeviceinputreports_unpack(buf []byte) ?CHidmessageFromRemoteDeviceInputReports { +mut res := CHidmessageFromRemoteDeviceInputReports{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_chidmessagefromremotedeviceinputreportsdeviceinputreport(cur_buf, tag_wiretype.wire_type)? +res.device_reports << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_chidmessagefromremotedeviceinputreports() CHidmessageFromRemoteDeviceInputReports { +return CHidmessageFromRemoteDeviceInputReports{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_chidmessagefromremotedeviceinputreports(o CHidmessageFromRemoteDeviceInputReports, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_chidmessagefromremotedeviceinputreports(buf []byte, tag_wiretype vproto.WireType) ?(int, CHidmessageFromRemoteDeviceInputReports) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := chidmessagefromremotedeviceinputreports_unpack(v)? +return i, unpacked +} +pub struct CHidmessageFromRemoteCloseDevice { +mut: +unknown_fields []vproto.UnknownField +pub mut: +device u32 +has_device bool +} +pub fn (o &CHidmessageFromRemoteCloseDevice) pack() []byte { +mut res := []byte{} +if o.has_device { +res << vproto.pack_uint32_field(o.device, 1) +} + +return res +} + +pub fn chidmessagefromremoteclosedevice_unpack(buf []byte) ?CHidmessageFromRemoteCloseDevice { +mut res := CHidmessageFromRemoteCloseDevice{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_device = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.device = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_chidmessagefromremoteclosedevice() CHidmessageFromRemoteCloseDevice { +return CHidmessageFromRemoteCloseDevice{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_chidmessagefromremoteclosedevice(o CHidmessageFromRemoteCloseDevice, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_chidmessagefromremoteclosedevice(buf []byte, tag_wiretype vproto.WireType) ?(int, CHidmessageFromRemoteCloseDevice) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := chidmessagefromremoteclosedevice_unpack(v)? +return i, unpacked +} +pub struct CHidmessageFromRemoteCloseAllDevices { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CHidmessageFromRemoteCloseAllDevices) pack() []byte { +res := []byte{} +return res +} + +pub fn chidmessagefromremoteclosealldevices_unpack(buf []byte) ?CHidmessageFromRemoteCloseAllDevices { +res := CHidmessageFromRemoteCloseAllDevices{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_chidmessagefromremoteclosealldevices() CHidmessageFromRemoteCloseAllDevices { +return CHidmessageFromRemoteCloseAllDevices{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_chidmessagefromremoteclosealldevices(o CHidmessageFromRemoteCloseAllDevices, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_chidmessagefromremoteclosealldevices(buf []byte, tag_wiretype vproto.WireType) ?(int, CHidmessageFromRemoteCloseAllDevices) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := chidmessagefromremoteclosealldevices_unpack(v)? +return i, unpacked +} +pub struct CHidmessageFromRemote { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CHidmessageFromRemote) pack() []byte { +res := []byte{} +return res +} + +pub fn chidmessagefromremote_unpack(buf []byte) ?CHidmessageFromRemote { +res := CHidmessageFromRemote{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_chidmessagefromremote() CHidmessageFromRemote { +return CHidmessageFromRemote{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_chidmessagefromremote(o CHidmessageFromRemote, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_chidmessagefromremote(buf []byte, tag_wiretype vproto.WireType) ?(int, CHidmessageFromRemote) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := chidmessagefromremote_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_inventory.steamclient_pb.v b/proto/steammessages_inventory.steamclient_pb.v new file mode 100644 index 0000000..0d169b1 --- /dev/null +++ b/proto/steammessages_inventory.steamclient_pb.v @@ -0,0 +1,1987 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CInventoryGetInventoryRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +steamid u64 +has_steamid bool +} +pub fn (o &CInventoryGetInventoryRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_steamid { +res << vproto.pack_uint64_field(o.steamid, 2) +} + +return res +} + +pub fn cinventorygetinventoryrequest_unpack(buf []byte) ?CInventoryGetInventoryRequest { +mut res := CInventoryGetInventoryRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_steamid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinventorygetinventoryrequest() CInventoryGetInventoryRequest { +return CInventoryGetInventoryRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinventorygetinventoryrequest(o CInventoryGetInventoryRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinventorygetinventoryrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CInventoryGetInventoryRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinventorygetinventoryrequest_unpack(v)? +return i, unpacked +} +pub struct CInventoryResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +etag string +has_etag bool +removeditemids []u64 +item_json string +has_item_json bool +itemdef_json string +has_itemdef_json bool +ticket []byte +has_ticket bool +replayed bool +has_replayed bool +} +pub fn (o &CInventoryResponse) pack() []byte { +mut res := []byte{} +if o.has_etag { +res << vproto.pack_string_field(o.etag, 1) +} + +// [packed=false] +for _, x in o.removeditemids { +res << vproto.pack_uint64_field(x, 2) +} + +if o.has_item_json { +res << vproto.pack_string_field(o.item_json, 3) +} + +if o.has_itemdef_json { +res << vproto.pack_string_field(o.itemdef_json, 4) +} + +if o.has_ticket { +res << vproto.pack_bytes_field(o.ticket, 5) +} + +if o.has_replayed { +res << vproto.pack_bool_field(o.replayed, 6) +} + +return res +} + +pub fn cinventoryresponse_unpack(buf []byte) ?CInventoryResponse { +mut res := CInventoryResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_etag = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.etag = v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.removeditemids << v +i = ii +} + +3 { +res.has_item_json = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.item_json = v +i = ii +} + +4 { +res.has_itemdef_json = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.itemdef_json = v +i = ii +} + +5 { +res.has_ticket = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.ticket = v +i = ii +} + +6 { +res.has_replayed = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.replayed = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinventoryresponse() CInventoryResponse { +return CInventoryResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinventoryresponse(o CInventoryResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinventoryresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CInventoryResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinventoryresponse_unpack(v)? +return i, unpacked +} +pub struct CInventoryExchangeItemRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +steamid u64 +has_steamid bool +materialsitemid []u64 +materialsquantity []u32 +outputitemdefid u64 +has_outputitemdefid bool +} +pub fn (o &CInventoryExchangeItemRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_steamid { +res << vproto.pack_uint64_field(o.steamid, 2) +} + +// [packed=false] +for _, x in o.materialsitemid { +res << vproto.pack_uint64_field(x, 3) +} + +// [packed=false] +for _, x in o.materialsquantity { +res << vproto.pack_uint32_field(x, 4) +} + +if o.has_outputitemdefid { +res << vproto.pack_uint64_field(o.outputitemdefid, 5) +} + +return res +} + +pub fn cinventoryexchangeitemrequest_unpack(buf []byte) ?CInventoryExchangeItemRequest { +mut res := CInventoryExchangeItemRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_steamid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +3 { +// [packed=false] +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.materialsitemid << v +i = ii +} + +4 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.materialsquantity << v +i = ii +} + +5 { +res.has_outputitemdefid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.outputitemdefid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinventoryexchangeitemrequest() CInventoryExchangeItemRequest { +return CInventoryExchangeItemRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinventoryexchangeitemrequest(o CInventoryExchangeItemRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinventoryexchangeitemrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CInventoryExchangeItemRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinventoryexchangeitemrequest_unpack(v)? +return i, unpacked +} +pub struct CInventoryGetEligiblePromoItemDefIDsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +steamid u64 +has_steamid bool +} +pub fn (o &CInventoryGetEligiblePromoItemDefIDsRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_steamid { +res << vproto.pack_uint64_field(o.steamid, 2) +} + +return res +} + +pub fn cinventorygeteligiblepromoitemdefidsrequest_unpack(buf []byte) ?CInventoryGetEligiblePromoItemDefIDsRequest { +mut res := CInventoryGetEligiblePromoItemDefIDsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_steamid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinventorygeteligiblepromoitemdefidsrequest() CInventoryGetEligiblePromoItemDefIDsRequest { +return CInventoryGetEligiblePromoItemDefIDsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinventorygeteligiblepromoitemdefidsrequest(o CInventoryGetEligiblePromoItemDefIDsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinventorygeteligiblepromoitemdefidsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CInventoryGetEligiblePromoItemDefIDsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinventorygeteligiblepromoitemdefidsrequest_unpack(v)? +return i, unpacked +} +pub struct CInventoryGetEligiblePromoItemDefIDsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +itemdefids []u64 +} +pub fn (o &CInventoryGetEligiblePromoItemDefIDsResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.itemdefids { +res << vproto.pack_uint64_field(x, 1) +} + +return res +} + +pub fn cinventorygeteligiblepromoitemdefidsresponse_unpack(buf []byte) ?CInventoryGetEligiblePromoItemDefIDsResponse { +mut res := CInventoryGetEligiblePromoItemDefIDsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.itemdefids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinventorygeteligiblepromoitemdefidsresponse() CInventoryGetEligiblePromoItemDefIDsResponse { +return CInventoryGetEligiblePromoItemDefIDsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinventorygeteligiblepromoitemdefidsresponse(o CInventoryGetEligiblePromoItemDefIDsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinventorygeteligiblepromoitemdefidsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CInventoryGetEligiblePromoItemDefIDsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinventorygeteligiblepromoitemdefidsresponse_unpack(v)? +return i, unpacked +} +pub struct CInventoryAddItemRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +itemdefid []u64 +itempropsjson []string +steamid u64 +has_steamid bool +notify bool +has_notify bool +requestid u64 +has_requestid bool +trade_restriction bool +has_trade_restriction bool +is_purchase bool +has_is_purchase bool +} +pub fn (o &CInventoryAddItemRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +// [packed=false] +for _, x in o.itemdefid { +res << vproto.pack_uint64_field(x, 2) +} + +// [packed=false] +for _, x in o.itempropsjson { +res << vproto.pack_string_field(x, 3) +} + +if o.has_steamid { +res << vproto.pack_uint64_field(o.steamid, 4) +} + +if o.has_notify { +res << vproto.pack_bool_field(o.notify, 5) +} + +if o.has_requestid { +res << vproto.pack_uint64_field(o.requestid, 6) +} + +if o.has_trade_restriction { +res << vproto.pack_bool_field(o.trade_restriction, 7) +} + +if o.has_is_purchase { +res << vproto.pack_bool_field(o.is_purchase, 8) +} + +return res +} + +pub fn cinventoryadditemrequest_unpack(buf []byte) ?CInventoryAddItemRequest { +mut res := CInventoryAddItemRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.itemdefid << v +i = ii +} + +3 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.itempropsjson << v +i = ii +} + +4 { +res.has_steamid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +5 { +res.has_notify = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.notify = v +i = ii +} + +6 { +res.has_requestid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.requestid = v +i = ii +} + +7 { +res.has_trade_restriction = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.trade_restriction = v +i = ii +} + +8 { +res.has_is_purchase = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_purchase = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinventoryadditemrequest() CInventoryAddItemRequest { +return CInventoryAddItemRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinventoryadditemrequest(o CInventoryAddItemRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinventoryadditemrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CInventoryAddItemRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinventoryadditemrequest_unpack(v)? +return i, unpacked +} +pub struct CInventoryModifyItemsRequestItemPropertyUpdate { +mut: +unknown_fields []vproto.UnknownField +pub mut: +itemid u64 +has_itemid bool +remove_property bool +has_remove_property bool +property_name string +has_property_name bool +property_value_bool bool +has_property_value_bool bool +property_value_int i64 +has_property_value_int bool +property_value_string string +has_property_value_string bool +property_value_float f32 +has_property_value_float bool +} +pub fn (o &CInventoryModifyItemsRequestItemPropertyUpdate) pack() []byte { +mut res := []byte{} +if o.has_itemid { +res << vproto.pack_uint64_field(o.itemid, 1) +} + +if o.has_remove_property { +res << vproto.pack_bool_field(o.remove_property, 2) +} + +if o.has_property_name { +res << vproto.pack_string_field(o.property_name, 3) +} + +if o.has_property_value_bool { +res << vproto.pack_bool_field(o.property_value_bool, 4) +} + +if o.has_property_value_int { +res << vproto.pack_int64_field(o.property_value_int, 5) +} + +if o.has_property_value_string { +res << vproto.pack_string_field(o.property_value_string, 6) +} + +if o.has_property_value_float { +res << vproto.pack_float_field(o.property_value_float, 7) +} + +return res +} + +pub fn cinventorymodifyitemsrequestitempropertyupdate_unpack(buf []byte) ?CInventoryModifyItemsRequestItemPropertyUpdate { +mut res := CInventoryModifyItemsRequestItemPropertyUpdate{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_itemid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.itemid = v +i = ii +} + +2 { +res.has_remove_property = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.remove_property = v +i = ii +} + +3 { +res.has_property_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.property_name = v +i = ii +} + +4 { +res.has_property_value_bool = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.property_value_bool = v +i = ii +} + +5 { +res.has_property_value_int = true +ii, v := vproto.unpack_int64_field(cur_buf, tag_wiretype.wire_type)? +res.property_value_int = v +i = ii +} + +6 { +res.has_property_value_string = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.property_value_string = v +i = ii +} + +7 { +res.has_property_value_float = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.property_value_float = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinventorymodifyitemsrequestitempropertyupdate() CInventoryModifyItemsRequestItemPropertyUpdate { +return CInventoryModifyItemsRequestItemPropertyUpdate{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinventorymodifyitemsrequestitempropertyupdate(o CInventoryModifyItemsRequestItemPropertyUpdate, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinventorymodifyitemsrequestitempropertyupdate(buf []byte, tag_wiretype vproto.WireType) ?(int, CInventoryModifyItemsRequestItemPropertyUpdate) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinventorymodifyitemsrequestitempropertyupdate_unpack(v)? +return i, unpacked +} +pub struct CInventoryModifyItemsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +steamid u64 +has_steamid bool +updates []CInventoryModifyItemsRequestItemPropertyUpdate +timestamp u32 +has_timestamp bool +} +pub fn (o &CInventoryModifyItemsRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_steamid { +res << vproto.pack_uint64_field(o.steamid, 2) +} + +// [packed=false] +for _, x in o.updates { +res << zzz_vproto_internal_pack_cinventorymodifyitemsrequestitempropertyupdate(x, 3) +} + +if o.has_timestamp { +res << vproto.pack_uint32_field(o.timestamp, 4) +} + +return res +} + +pub fn cinventorymodifyitemsrequest_unpack(buf []byte) ?CInventoryModifyItemsRequest { +mut res := CInventoryModifyItemsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_steamid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cinventorymodifyitemsrequestitempropertyupdate(cur_buf, tag_wiretype.wire_type)? +res.updates << v +i = ii +} + +4 { +res.has_timestamp = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinventorymodifyitemsrequest() CInventoryModifyItemsRequest { +return CInventoryModifyItemsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinventorymodifyitemsrequest(o CInventoryModifyItemsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinventorymodifyitemsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CInventoryModifyItemsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinventorymodifyitemsrequest_unpack(v)? +return i, unpacked +} +pub struct CInventoryConsumePlaytimeRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +itemdefid u64 +has_itemdefid bool +} +pub fn (o &CInventoryConsumePlaytimeRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_itemdefid { +res << vproto.pack_uint64_field(o.itemdefid, 2) +} + +return res +} + +pub fn cinventoryconsumeplaytimerequest_unpack(buf []byte) ?CInventoryConsumePlaytimeRequest { +mut res := CInventoryConsumePlaytimeRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_itemdefid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.itemdefid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinventoryconsumeplaytimerequest() CInventoryConsumePlaytimeRequest { +return CInventoryConsumePlaytimeRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinventoryconsumeplaytimerequest(o CInventoryConsumePlaytimeRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinventoryconsumeplaytimerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CInventoryConsumePlaytimeRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinventoryconsumeplaytimerequest_unpack(v)? +return i, unpacked +} +pub struct CInventoryConsumeItemRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +itemid u64 +has_itemid bool +quantity u32 +has_quantity bool +timestamp string +has_timestamp bool +steamid u64 +has_steamid bool +requestid u64 +has_requestid bool +} +pub fn (o &CInventoryConsumeItemRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_itemid { +res << vproto.pack_uint64_field(o.itemid, 2) +} + +if o.has_quantity { +res << vproto.pack_uint32_field(o.quantity, 3) +} + +if o.has_timestamp { +res << vproto.pack_string_field(o.timestamp, 4) +} + +if o.has_steamid { +res << vproto.pack_uint64_field(o.steamid, 5) +} + +if o.has_requestid { +res << vproto.pack_uint64_field(o.requestid, 6) +} + +return res +} + +pub fn cinventoryconsumeitemrequest_unpack(buf []byte) ?CInventoryConsumeItemRequest { +mut res := CInventoryConsumeItemRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_itemid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.itemid = v +i = ii +} + +3 { +res.has_quantity = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.quantity = v +i = ii +} + +4 { +res.has_timestamp = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp = v +i = ii +} + +5 { +res.has_steamid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +6 { +res.has_requestid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.requestid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinventoryconsumeitemrequest() CInventoryConsumeItemRequest { +return CInventoryConsumeItemRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinventoryconsumeitemrequest(o CInventoryConsumeItemRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinventoryconsumeitemrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CInventoryConsumeItemRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinventoryconsumeitemrequest_unpack(v)? +return i, unpacked +} +pub struct CInventoryDevSetNextDropRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +itemdefid u64 +has_itemdefid bool +droptime string +has_droptime bool +} +pub fn (o &CInventoryDevSetNextDropRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_itemdefid { +res << vproto.pack_uint64_field(o.itemdefid, 2) +} + +if o.has_droptime { +res << vproto.pack_string_field(o.droptime, 3) +} + +return res +} + +pub fn cinventorydevsetnextdroprequest_unpack(buf []byte) ?CInventoryDevSetNextDropRequest { +mut res := CInventoryDevSetNextDropRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_itemdefid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.itemdefid = v +i = ii +} + +3 { +res.has_droptime = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.droptime = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinventorydevsetnextdroprequest() CInventoryDevSetNextDropRequest { +return CInventoryDevSetNextDropRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinventorydevsetnextdroprequest(o CInventoryDevSetNextDropRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinventorydevsetnextdroprequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CInventoryDevSetNextDropRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinventorydevsetnextdroprequest_unpack(v)? +return i, unpacked +} +pub struct CInventorySplitItemStackRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +itemid u64 +has_itemid bool +quantity u32 +has_quantity bool +steamid u64 +has_steamid bool +} +pub fn (o &CInventorySplitItemStackRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_itemid { +res << vproto.pack_uint64_field(o.itemid, 2) +} + +if o.has_quantity { +res << vproto.pack_uint32_field(o.quantity, 3) +} + +if o.has_steamid { +res << vproto.pack_uint64_field(o.steamid, 5) +} + +return res +} + +pub fn cinventorysplititemstackrequest_unpack(buf []byte) ?CInventorySplitItemStackRequest { +mut res := CInventorySplitItemStackRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_itemid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.itemid = v +i = ii +} + +3 { +res.has_quantity = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.quantity = v +i = ii +} + +5 { +res.has_steamid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinventorysplititemstackrequest() CInventorySplitItemStackRequest { +return CInventorySplitItemStackRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinventorysplititemstackrequest(o CInventorySplitItemStackRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinventorysplititemstackrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CInventorySplitItemStackRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinventorysplititemstackrequest_unpack(v)? +return i, unpacked +} +pub struct CInventoryCombineItemStacksRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +fromitemid u64 +has_fromitemid bool +destitemid u64 +has_destitemid bool +quantity u32 +has_quantity bool +steamid u64 +has_steamid bool +} +pub fn (o &CInventoryCombineItemStacksRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_fromitemid { +res << vproto.pack_uint64_field(o.fromitemid, 2) +} + +if o.has_destitemid { +res << vproto.pack_uint64_field(o.destitemid, 3) +} + +if o.has_quantity { +res << vproto.pack_uint32_field(o.quantity, 4) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 7) +} + +return res +} + +pub fn cinventorycombineitemstacksrequest_unpack(buf []byte) ?CInventoryCombineItemStacksRequest { +mut res := CInventoryCombineItemStacksRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_fromitemid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.fromitemid = v +i = ii +} + +3 { +res.has_destitemid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.destitemid = v +i = ii +} + +4 { +res.has_quantity = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.quantity = v +i = ii +} + +7 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinventorycombineitemstacksrequest() CInventoryCombineItemStacksRequest { +return CInventoryCombineItemStacksRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinventorycombineitemstacksrequest(o CInventoryCombineItemStacksRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinventorycombineitemstacksrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CInventoryCombineItemStacksRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinventorycombineitemstacksrequest_unpack(v)? +return i, unpacked +} +pub struct CInventoryGetItemDefMetaRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +} +pub fn (o &CInventoryGetItemDefMetaRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +return res +} + +pub fn cinventorygetitemdefmetarequest_unpack(buf []byte) ?CInventoryGetItemDefMetaRequest { +mut res := CInventoryGetItemDefMetaRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinventorygetitemdefmetarequest() CInventoryGetItemDefMetaRequest { +return CInventoryGetItemDefMetaRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinventorygetitemdefmetarequest(o CInventoryGetItemDefMetaRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinventorygetitemdefmetarequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CInventoryGetItemDefMetaRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinventorygetitemdefmetarequest_unpack(v)? +return i, unpacked +} +pub struct CInventoryGetItemDefMetaResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +modified u32 +has_modified bool +digest string +has_digest bool +} +pub fn (o &CInventoryGetItemDefMetaResponse) pack() []byte { +mut res := []byte{} +if o.has_modified { +res << vproto.pack_uint32_field(o.modified, 1) +} + +if o.has_digest { +res << vproto.pack_string_field(o.digest, 2) +} + +return res +} + +pub fn cinventorygetitemdefmetaresponse_unpack(buf []byte) ?CInventoryGetItemDefMetaResponse { +mut res := CInventoryGetItemDefMetaResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_modified = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.modified = v +i = ii +} + +2 { +res.has_digest = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.digest = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinventorygetitemdefmetaresponse() CInventoryGetItemDefMetaResponse { +return CInventoryGetItemDefMetaResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinventorygetitemdefmetaresponse(o CInventoryGetItemDefMetaResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinventorygetitemdefmetaresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CInventoryGetItemDefMetaResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinventorygetitemdefmetaresponse_unpack(v)? +return i, unpacked +} +pub struct CInventoryGetUserPurchaseInfoRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CInventoryGetUserPurchaseInfoRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn cinventorygetuserpurchaseinforequest_unpack(buf []byte) ?CInventoryGetUserPurchaseInfoRequest { +res := CInventoryGetUserPurchaseInfoRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinventorygetuserpurchaseinforequest() CInventoryGetUserPurchaseInfoRequest { +return CInventoryGetUserPurchaseInfoRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinventorygetuserpurchaseinforequest(o CInventoryGetUserPurchaseInfoRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinventorygetuserpurchaseinforequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CInventoryGetUserPurchaseInfoRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinventorygetuserpurchaseinforequest_unpack(v)? +return i, unpacked +} +pub struct CInventoryGetUserPurchaseInfoResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +ecurrency int +has_ecurrency bool +} +pub fn (o &CInventoryGetUserPurchaseInfoResponse) pack() []byte { +mut res := []byte{} +if o.has_ecurrency { +res << vproto.pack_int32_field(o.ecurrency, 1) +} + +return res +} + +pub fn cinventorygetuserpurchaseinforesponse_unpack(buf []byte) ?CInventoryGetUserPurchaseInfoResponse { +mut res := CInventoryGetUserPurchaseInfoResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_ecurrency = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.ecurrency = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinventorygetuserpurchaseinforesponse() CInventoryGetUserPurchaseInfoResponse { +return CInventoryGetUserPurchaseInfoResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinventorygetuserpurchaseinforesponse(o CInventoryGetUserPurchaseInfoResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinventorygetuserpurchaseinforesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CInventoryGetUserPurchaseInfoResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinventorygetuserpurchaseinforesponse_unpack(v)? +return i, unpacked +} +pub struct CInventoryPurchaseInitRequestLineItem { +mut: +unknown_fields []vproto.UnknownField +pub mut: +itemdefid u64 +has_itemdefid bool +quantity u32 +has_quantity bool +} +pub fn (o &CInventoryPurchaseInitRequestLineItem) pack() []byte { +mut res := []byte{} +if o.has_itemdefid { +res << vproto.pack_uint64_field(o.itemdefid, 1) +} + +if o.has_quantity { +res << vproto.pack_uint32_field(o.quantity, 2) +} + +return res +} + +pub fn cinventorypurchaseinitrequestlineitem_unpack(buf []byte) ?CInventoryPurchaseInitRequestLineItem { +mut res := CInventoryPurchaseInitRequestLineItem{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_itemdefid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.itemdefid = v +i = ii +} + +2 { +res.has_quantity = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.quantity = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinventorypurchaseinitrequestlineitem() CInventoryPurchaseInitRequestLineItem { +return CInventoryPurchaseInitRequestLineItem{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinventorypurchaseinitrequestlineitem(o CInventoryPurchaseInitRequestLineItem, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinventorypurchaseinitrequestlineitem(buf []byte, tag_wiretype vproto.WireType) ?(int, CInventoryPurchaseInitRequestLineItem) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinventorypurchaseinitrequestlineitem_unpack(v)? +return i, unpacked +} +pub struct CInventoryPurchaseInitRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +language int +has_language bool +line_items []CInventoryPurchaseInitRequestLineItem +} +pub fn (o &CInventoryPurchaseInitRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_language { +res << vproto.pack_int32_field(o.language, 2) +} + +// [packed=false] +for _, x in o.line_items { +res << zzz_vproto_internal_pack_cinventorypurchaseinitrequestlineitem(x, 3) +} + +return res +} + +pub fn cinventorypurchaseinitrequest_unpack(buf []byte) ?CInventoryPurchaseInitRequest { +mut res := CInventoryPurchaseInitRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_language = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cinventorypurchaseinitrequestlineitem(cur_buf, tag_wiretype.wire_type)? +res.line_items << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinventorypurchaseinitrequest() CInventoryPurchaseInitRequest { +return CInventoryPurchaseInitRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinventorypurchaseinitrequest(o CInventoryPurchaseInitRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinventorypurchaseinitrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CInventoryPurchaseInitRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinventorypurchaseinitrequest_unpack(v)? +return i, unpacked +} +pub struct CInventoryPurchaseInitResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +orderid u64 +has_orderid bool +transid u64 +has_transid bool +} +pub fn (o &CInventoryPurchaseInitResponse) pack() []byte { +mut res := []byte{} +if o.has_orderid { +res << vproto.pack_uint64_field(o.orderid, 1) +} + +if o.has_transid { +res << vproto.pack_uint64_field(o.transid, 2) +} + +return res +} + +pub fn cinventorypurchaseinitresponse_unpack(buf []byte) ?CInventoryPurchaseInitResponse { +mut res := CInventoryPurchaseInitResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_orderid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.orderid = v +i = ii +} + +2 { +res.has_transid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.transid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinventorypurchaseinitresponse() CInventoryPurchaseInitResponse { +return CInventoryPurchaseInitResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinventorypurchaseinitresponse(o CInventoryPurchaseInitResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinventorypurchaseinitresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CInventoryPurchaseInitResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinventorypurchaseinitresponse_unpack(v)? +return i, unpacked +} +pub struct CInventoryPurchaseFinalizeRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +language int +has_language bool +orderid u64 +has_orderid bool +} +pub fn (o &CInventoryPurchaseFinalizeRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_language { +res << vproto.pack_int32_field(o.language, 2) +} + +if o.has_orderid { +res << vproto.pack_uint64_field(o.orderid, 3) +} + +return res +} + +pub fn cinventorypurchasefinalizerequest_unpack(buf []byte) ?CInventoryPurchaseFinalizeRequest { +mut res := CInventoryPurchaseFinalizeRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_language = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +3 { +res.has_orderid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.orderid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinventorypurchasefinalizerequest() CInventoryPurchaseFinalizeRequest { +return CInventoryPurchaseFinalizeRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinventorypurchasefinalizerequest(o CInventoryPurchaseFinalizeRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinventorypurchasefinalizerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CInventoryPurchaseFinalizeRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinventorypurchasefinalizerequest_unpack(v)? +return i, unpacked +} +pub struct CInventoryInspectItemRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +itemdefid u64 +has_itemdefid bool +itemid u64 +has_itemid bool +tags string +has_tags bool +} +pub fn (o &CInventoryInspectItemRequest) pack() []byte { +mut res := []byte{} +if o.has_itemdefid { +res << vproto.pack_uint64_field(o.itemdefid, 1) +} + +if o.has_itemid { +res << vproto.pack_64bit_field(o.itemid, 2) +} + +if o.has_tags { +res << vproto.pack_string_field(o.tags, 3) +} + +return res +} + +pub fn cinventoryinspectitemrequest_unpack(buf []byte) ?CInventoryInspectItemRequest { +mut res := CInventoryInspectItemRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_itemdefid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.itemdefid = v +i = ii +} + +2 { +res.has_itemid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.itemid = v +i = ii +} + +3 { +res.has_tags = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.tags = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinventoryinspectitemrequest() CInventoryInspectItemRequest { +return CInventoryInspectItemRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinventoryinspectitemrequest(o CInventoryInspectItemRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinventoryinspectitemrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CInventoryInspectItemRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinventoryinspectitemrequest_unpack(v)? +return i, unpacked +} +pub struct CInventoryClientNewItemsNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +inventory_response CInventoryResponse +has_inventory_response bool +} +pub fn (o &CInventoryClientNewItemsNotification) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_inventory_response { +res << zzz_vproto_internal_pack_cinventoryresponse(o.inventory_response, 2) +} + +return res +} + +pub fn cinventoryclientnewitemsnotification_unpack(buf []byte) ?CInventoryClientNewItemsNotification { +mut res := CInventoryClientNewItemsNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_inventory_response = true +ii, v := zzz_vproto_internal_unpack_cinventoryresponse(cur_buf, tag_wiretype.wire_type)? +res.inventory_response = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinventoryclientnewitemsnotification() CInventoryClientNewItemsNotification { +return CInventoryClientNewItemsNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinventoryclientnewitemsnotification(o CInventoryClientNewItemsNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinventoryclientnewitemsnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CInventoryClientNewItemsNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinventoryclientnewitemsnotification_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_linkfilter.steamclient_pb.v b/proto/steammessages_linkfilter.steamclient_pb.v new file mode 100644 index 0000000..3a0b8dc --- /dev/null +++ b/proto/steammessages_linkfilter.steamclient_pb.v @@ -0,0 +1,420 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CCommunityGetLinkFilterHashPrefixesRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +hit_type u32 +has_hit_type bool +count u32 +has_count bool +start u64 +has_start bool +} +pub fn (o &CCommunityGetLinkFilterHashPrefixesRequest) pack() []byte { +mut res := []byte{} +if o.has_hit_type { +res << vproto.pack_uint32_field(o.hit_type, 1) +} + +if o.has_count { +res << vproto.pack_uint32_field(o.count, 2) +} + +if o.has_start { +res << vproto.pack_uint64_field(o.start, 3) +} + +return res +} + +pub fn ccommunitygetlinkfilterhashprefixesrequest_unpack(buf []byte) ?CCommunityGetLinkFilterHashPrefixesRequest { +mut res := CCommunityGetLinkFilterHashPrefixesRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_hit_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.hit_type = v +i = ii +} + +2 { +res.has_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.count = v +i = ii +} + +3 { +res.has_start = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.start = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccommunitygetlinkfilterhashprefixesrequest() CCommunityGetLinkFilterHashPrefixesRequest { +return CCommunityGetLinkFilterHashPrefixesRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccommunitygetlinkfilterhashprefixesrequest(o CCommunityGetLinkFilterHashPrefixesRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccommunitygetlinkfilterhashprefixesrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CCommunityGetLinkFilterHashPrefixesRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccommunitygetlinkfilterhashprefixesrequest_unpack(v)? +return i, unpacked +} +pub struct CCommunityGetLinkFilterHashPrefixesResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +hash_prefixes []u32 +} +pub fn (o &CCommunityGetLinkFilterHashPrefixesResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.hash_prefixes { +res << vproto.pack_uint32_field(x, 1) +} + +return res +} + +pub fn ccommunitygetlinkfilterhashprefixesresponse_unpack(buf []byte) ?CCommunityGetLinkFilterHashPrefixesResponse { +mut res := CCommunityGetLinkFilterHashPrefixesResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.hash_prefixes << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccommunitygetlinkfilterhashprefixesresponse() CCommunityGetLinkFilterHashPrefixesResponse { +return CCommunityGetLinkFilterHashPrefixesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccommunitygetlinkfilterhashprefixesresponse(o CCommunityGetLinkFilterHashPrefixesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccommunitygetlinkfilterhashprefixesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CCommunityGetLinkFilterHashPrefixesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccommunitygetlinkfilterhashprefixesresponse_unpack(v)? +return i, unpacked +} +pub struct CCommunityGetLinkFilterHashesRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +hit_type u32 +has_hit_type bool +count u32 +has_count bool +start u64 +has_start bool +} +pub fn (o &CCommunityGetLinkFilterHashesRequest) pack() []byte { +mut res := []byte{} +if o.has_hit_type { +res << vproto.pack_uint32_field(o.hit_type, 1) +} + +if o.has_count { +res << vproto.pack_uint32_field(o.count, 2) +} + +if o.has_start { +res << vproto.pack_uint64_field(o.start, 3) +} + +return res +} + +pub fn ccommunitygetlinkfilterhashesrequest_unpack(buf []byte) ?CCommunityGetLinkFilterHashesRequest { +mut res := CCommunityGetLinkFilterHashesRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_hit_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.hit_type = v +i = ii +} + +2 { +res.has_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.count = v +i = ii +} + +3 { +res.has_start = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.start = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccommunitygetlinkfilterhashesrequest() CCommunityGetLinkFilterHashesRequest { +return CCommunityGetLinkFilterHashesRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccommunitygetlinkfilterhashesrequest(o CCommunityGetLinkFilterHashesRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccommunitygetlinkfilterhashesrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CCommunityGetLinkFilterHashesRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccommunitygetlinkfilterhashesrequest_unpack(v)? +return i, unpacked +} +pub struct CCommunityGetLinkFilterHashesResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +hashes [][]byte +} +pub fn (o &CCommunityGetLinkFilterHashesResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.hashes { +res << vproto.pack_bytes_field(x, 1) +} + +return res +} + +pub fn ccommunitygetlinkfilterhashesresponse_unpack(buf []byte) ?CCommunityGetLinkFilterHashesResponse { +mut res := CCommunityGetLinkFilterHashesResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.hashes << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccommunitygetlinkfilterhashesresponse() CCommunityGetLinkFilterHashesResponse { +return CCommunityGetLinkFilterHashesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccommunitygetlinkfilterhashesresponse(o CCommunityGetLinkFilterHashesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccommunitygetlinkfilterhashesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CCommunityGetLinkFilterHashesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccommunitygetlinkfilterhashesresponse_unpack(v)? +return i, unpacked +} +pub struct CCommunityGetLinkFilterListVersionRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +hit_type u32 +has_hit_type bool +} +pub fn (o &CCommunityGetLinkFilterListVersionRequest) pack() []byte { +mut res := []byte{} +if o.has_hit_type { +res << vproto.pack_uint32_field(o.hit_type, 1) +} + +return res +} + +pub fn ccommunitygetlinkfilterlistversionrequest_unpack(buf []byte) ?CCommunityGetLinkFilterListVersionRequest { +mut res := CCommunityGetLinkFilterListVersionRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_hit_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.hit_type = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccommunitygetlinkfilterlistversionrequest() CCommunityGetLinkFilterListVersionRequest { +return CCommunityGetLinkFilterListVersionRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccommunitygetlinkfilterlistversionrequest(o CCommunityGetLinkFilterListVersionRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccommunitygetlinkfilterlistversionrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CCommunityGetLinkFilterListVersionRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccommunitygetlinkfilterlistversionrequest_unpack(v)? +return i, unpacked +} +pub struct CCommunityGetLinkFilterListVersionResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +version string +has_version bool +count u64 +has_count bool +} +pub fn (o &CCommunityGetLinkFilterListVersionResponse) pack() []byte { +mut res := []byte{} +if o.has_version { +res << vproto.pack_string_field(o.version, 1) +} + +if o.has_count { +res << vproto.pack_uint64_field(o.count, 2) +} + +return res +} + +pub fn ccommunitygetlinkfilterlistversionresponse_unpack(buf []byte) ?CCommunityGetLinkFilterListVersionResponse { +mut res := CCommunityGetLinkFilterListVersionResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_version = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.version = v +i = ii +} + +2 { +res.has_count = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.count = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ccommunitygetlinkfilterlistversionresponse() CCommunityGetLinkFilterListVersionResponse { +return CCommunityGetLinkFilterListVersionResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ccommunitygetlinkfilterlistversionresponse(o CCommunityGetLinkFilterListVersionResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ccommunitygetlinkfilterlistversionresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CCommunityGetLinkFilterListVersionResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ccommunitygetlinkfilterlistversionresponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_lobbymatchmaking.steamclient_pb.v b/proto/steammessages_lobbymatchmaking.steamclient_pb.v new file mode 100644 index 0000000..e812986 --- /dev/null +++ b/proto/steammessages_lobbymatchmaking.steamclient_pb.v @@ -0,0 +1,217 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +[_allow_multiple_values] +enum ELobbyStatus { +k_elobbystatusinvalid = 0 +k_elobbystatusexists = 1 +k_elobbystatusdoesnotexist = 2 +k_elobbystatusnotamember = 3 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_elobbystatus(e ELobbyStatus, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_elobbystatus(buf []byte, tag_wiretype vproto.WireType) ?(int, ELobbyStatus) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, ELobbyStatus(v) +} +pub struct LobbyMatchmakingLegacyGetLobbyStatusRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +steamid_lobby u64 +has_steamid_lobby bool +claim_ownership bool +has_claim_ownership bool +claim_membership bool +has_claim_membership bool +version_num u32 +has_version_num bool +} +pub fn (o &LobbyMatchmakingLegacyGetLobbyStatusRequest) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_steamid_lobby { +res << vproto.pack_64bit_field(o.steamid_lobby, 2) +} + +if o.has_claim_ownership { +res << vproto.pack_bool_field(o.claim_ownership, 3) +} + +if o.has_claim_membership { +res << vproto.pack_bool_field(o.claim_membership, 4) +} + +if o.has_version_num { +res << vproto.pack_uint32_field(o.version_num, 5) +} + +return res +} + +pub fn lobbymatchmakinglegacygetlobbystatusrequest_unpack(buf []byte) ?LobbyMatchmakingLegacyGetLobbyStatusRequest { +mut res := LobbyMatchmakingLegacyGetLobbyStatusRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_steamid_lobby = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_lobby = v +i = ii +} + +3 { +res.has_claim_ownership = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.claim_ownership = v +i = ii +} + +4 { +res.has_claim_membership = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.claim_membership = v +i = ii +} + +5 { +res.has_version_num = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.version_num = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_lobbymatchmakinglegacygetlobbystatusrequest() LobbyMatchmakingLegacyGetLobbyStatusRequest { +return LobbyMatchmakingLegacyGetLobbyStatusRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_lobbymatchmakinglegacygetlobbystatusrequest(o LobbyMatchmakingLegacyGetLobbyStatusRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_lobbymatchmakinglegacygetlobbystatusrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, LobbyMatchmakingLegacyGetLobbyStatusRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := lobbymatchmakinglegacygetlobbystatusrequest_unpack(v)? +return i, unpacked +} +pub struct LobbyMatchmakingLegacyGetLobbyStatusResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +steamid_lobby u64 +has_steamid_lobby bool +lobby_status ELobbyStatus +has_lobby_status bool +} +pub fn (o &LobbyMatchmakingLegacyGetLobbyStatusResponse) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_steamid_lobby { +res << vproto.pack_64bit_field(o.steamid_lobby, 2) +} + +if o.has_lobby_status { +res << zzz_vproto_internal_pack_elobbystatus(o.lobby_status, 3) +} + +return res +} + +pub fn lobbymatchmakinglegacygetlobbystatusresponse_unpack(buf []byte) ?LobbyMatchmakingLegacyGetLobbyStatusResponse { +mut res := LobbyMatchmakingLegacyGetLobbyStatusResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_steamid_lobby = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_lobby = v +i = ii +} + +3 { +res.has_lobby_status = true +ii, v := zzz_vproto_internal_unpack_elobbystatus(cur_buf, tag_wiretype.wire_type)? +res.lobby_status = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_lobbymatchmakinglegacygetlobbystatusresponse() LobbyMatchmakingLegacyGetLobbyStatusResponse { +return LobbyMatchmakingLegacyGetLobbyStatusResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_lobbymatchmakinglegacygetlobbystatusresponse(o LobbyMatchmakingLegacyGetLobbyStatusResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_lobbymatchmakinglegacygetlobbystatusresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, LobbyMatchmakingLegacyGetLobbyStatusResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := lobbymatchmakinglegacygetlobbystatusresponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_market.steamclient_pb.v b/proto/steammessages_market.steamclient_pb.v new file mode 100644 index 0000000..866cf73 --- /dev/null +++ b/proto/steammessages_market.steamclient_pb.v @@ -0,0 +1,201 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CEconMarketIsMarketplaceAllowedRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +webcookie string +has_webcookie bool +} +pub fn (o &CEconMarketIsMarketplaceAllowedRequest) pack() []byte { +mut res := []byte{} +if o.has_webcookie { +res << vproto.pack_string_field(o.webcookie, 1) +} + +return res +} + +pub fn ceconmarketismarketplaceallowedrequest_unpack(buf []byte) ?CEconMarketIsMarketplaceAllowedRequest { +mut res := CEconMarketIsMarketplaceAllowedRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_webcookie = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.webcookie = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ceconmarketismarketplaceallowedrequest() CEconMarketIsMarketplaceAllowedRequest { +return CEconMarketIsMarketplaceAllowedRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ceconmarketismarketplaceallowedrequest(o CEconMarketIsMarketplaceAllowedRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ceconmarketismarketplaceallowedrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CEconMarketIsMarketplaceAllowedRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ceconmarketismarketplaceallowedrequest_unpack(v)? +return i, unpacked +} +pub struct CEconMarketIsMarketplaceAllowedResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +allowed bool +has_allowed bool +reason u32 +has_reason bool +allowed_at_time u32 +has_allowed_at_time bool +steamguard_required_days u32 +has_steamguard_required_days bool +forms_requested bool +has_forms_requested bool +forms_require_verification bool +has_forms_require_verification bool +new_device_cooldown_days u32 +has_new_device_cooldown_days bool +} +pub fn (o &CEconMarketIsMarketplaceAllowedResponse) pack() []byte { +mut res := []byte{} +if o.has_allowed { +res << vproto.pack_bool_field(o.allowed, 1) +} + +if o.has_reason { +res << vproto.pack_uint32_field(o.reason, 2) +} + +if o.has_allowed_at_time { +res << vproto.pack_uint32_field(o.allowed_at_time, 3) +} + +if o.has_steamguard_required_days { +res << vproto.pack_uint32_field(o.steamguard_required_days, 4) +} + +if o.has_forms_requested { +res << vproto.pack_bool_field(o.forms_requested, 7) +} + +if o.has_forms_require_verification { +res << vproto.pack_bool_field(o.forms_require_verification, 8) +} + +if o.has_new_device_cooldown_days { +res << vproto.pack_uint32_field(o.new_device_cooldown_days, 9) +} + +return res +} + +pub fn ceconmarketismarketplaceallowedresponse_unpack(buf []byte) ?CEconMarketIsMarketplaceAllowedResponse { +mut res := CEconMarketIsMarketplaceAllowedResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_allowed = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.allowed = v +i = ii +} + +2 { +res.has_reason = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.reason = v +i = ii +} + +3 { +res.has_allowed_at_time = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.allowed_at_time = v +i = ii +} + +4 { +res.has_steamguard_required_days = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.steamguard_required_days = v +i = ii +} + +7 { +res.has_forms_requested = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.forms_requested = v +i = ii +} + +8 { +res.has_forms_require_verification = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.forms_require_verification = v +i = ii +} + +9 { +res.has_new_device_cooldown_days = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.new_device_cooldown_days = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ceconmarketismarketplaceallowedresponse() CEconMarketIsMarketplaceAllowedResponse { +return CEconMarketIsMarketplaceAllowedResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ceconmarketismarketplaceallowedresponse(o CEconMarketIsMarketplaceAllowedResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ceconmarketismarketplaceallowedresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CEconMarketIsMarketplaceAllowedResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ceconmarketismarketplaceallowedresponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_offline.steamclient_pb.v b/proto/steammessages_offline.steamclient_pb.v new file mode 100644 index 0000000..38d4edd --- /dev/null +++ b/proto/steammessages_offline.steamclient_pb.v @@ -0,0 +1,293 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct COfflineGetOfflineLogonTicketRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +priority u32 +has_priority bool +} +pub fn (o &COfflineGetOfflineLogonTicketRequest) pack() []byte { +mut res := []byte{} +if o.has_priority { +res << vproto.pack_uint32_field(o.priority, 1) +} + +return res +} + +pub fn cofflinegetofflinelogonticketrequest_unpack(buf []byte) ?COfflineGetOfflineLogonTicketRequest { +mut res := COfflineGetOfflineLogonTicketRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_priority = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.priority = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cofflinegetofflinelogonticketrequest() COfflineGetOfflineLogonTicketRequest { +return COfflineGetOfflineLogonTicketRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cofflinegetofflinelogonticketrequest(o COfflineGetOfflineLogonTicketRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cofflinegetofflinelogonticketrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, COfflineGetOfflineLogonTicketRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cofflinegetofflinelogonticketrequest_unpack(v)? +return i, unpacked +} +pub struct COfflineGetOfflineLogonTicketResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +serialized_ticket []byte +has_serialized_ticket bool +signature []byte +has_signature bool +} +pub fn (o &COfflineGetOfflineLogonTicketResponse) pack() []byte { +mut res := []byte{} +if o.has_serialized_ticket { +res << vproto.pack_bytes_field(o.serialized_ticket, 1) +} + +if o.has_signature { +res << vproto.pack_bytes_field(o.signature, 2) +} + +return res +} + +pub fn cofflinegetofflinelogonticketresponse_unpack(buf []byte) ?COfflineGetOfflineLogonTicketResponse { +mut res := COfflineGetOfflineLogonTicketResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_serialized_ticket = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.serialized_ticket = v +i = ii +} + +2 { +res.has_signature = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.signature = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cofflinegetofflinelogonticketresponse() COfflineGetOfflineLogonTicketResponse { +return COfflineGetOfflineLogonTicketResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cofflinegetofflinelogonticketresponse(o COfflineGetOfflineLogonTicketResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cofflinegetofflinelogonticketresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, COfflineGetOfflineLogonTicketResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cofflinegetofflinelogonticketresponse_unpack(v)? +return i, unpacked +} +pub struct COfflineGetUnsignedOfflineLogonTicketRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &COfflineGetUnsignedOfflineLogonTicketRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn cofflinegetunsignedofflinelogonticketrequest_unpack(buf []byte) ?COfflineGetUnsignedOfflineLogonTicketRequest { +res := COfflineGetUnsignedOfflineLogonTicketRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cofflinegetunsignedofflinelogonticketrequest() COfflineGetUnsignedOfflineLogonTicketRequest { +return COfflineGetUnsignedOfflineLogonTicketRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cofflinegetunsignedofflinelogonticketrequest(o COfflineGetUnsignedOfflineLogonTicketRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cofflinegetunsignedofflinelogonticketrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, COfflineGetUnsignedOfflineLogonTicketRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cofflinegetunsignedofflinelogonticketrequest_unpack(v)? +return i, unpacked +} +pub struct COfflineOfflineLogonTicket { +mut: +unknown_fields []vproto.UnknownField +pub mut: +accountid u32 +has_accountid bool +rtime32_creation_time u32 +has_rtime32_creation_time bool +} +pub fn (o &COfflineOfflineLogonTicket) pack() []byte { +mut res := []byte{} +if o.has_accountid { +res << vproto.pack_uint32_field(o.accountid, 1) +} + +if o.has_rtime32_creation_time { +res << vproto.pack_32bit_field(o.rtime32_creation_time, 2) +} + +return res +} + +pub fn cofflineofflinelogonticket_unpack(buf []byte) ?COfflineOfflineLogonTicket { +mut res := COfflineOfflineLogonTicket{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_accountid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.accountid = v +i = ii +} + +2 { +res.has_rtime32_creation_time = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.rtime32_creation_time = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cofflineofflinelogonticket() COfflineOfflineLogonTicket { +return COfflineOfflineLogonTicket{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cofflineofflinelogonticket(o COfflineOfflineLogonTicket, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cofflineofflinelogonticket(buf []byte, tag_wiretype vproto.WireType) ?(int, COfflineOfflineLogonTicket) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cofflineofflinelogonticket_unpack(v)? +return i, unpacked +} +pub struct COfflineGetUnsignedOfflineLogonTicketResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +ticket COfflineOfflineLogonTicket +has_ticket bool +} +pub fn (o &COfflineGetUnsignedOfflineLogonTicketResponse) pack() []byte { +mut res := []byte{} +if o.has_ticket { +res << zzz_vproto_internal_pack_cofflineofflinelogonticket(o.ticket, 1) +} + +return res +} + +pub fn cofflinegetunsignedofflinelogonticketresponse_unpack(buf []byte) ?COfflineGetUnsignedOfflineLogonTicketResponse { +mut res := COfflineGetUnsignedOfflineLogonTicketResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_ticket = true +ii, v := zzz_vproto_internal_unpack_cofflineofflinelogonticket(cur_buf, tag_wiretype.wire_type)? +res.ticket = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cofflinegetunsignedofflinelogonticketresponse() COfflineGetUnsignedOfflineLogonTicketResponse { +return COfflineGetUnsignedOfflineLogonTicketResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cofflinegetunsignedofflinelogonticketresponse(o COfflineGetUnsignedOfflineLogonTicketResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cofflinegetunsignedofflinelogonticketresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, COfflineGetUnsignedOfflineLogonTicketResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cofflinegetunsignedofflinelogonticketresponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_parental.steamclient_pb.v b/proto/steammessages_parental.steamclient_pb.v new file mode 100644 index 0000000..5aee63a --- /dev/null +++ b/proto/steammessages_parental.steamclient_pb.v @@ -0,0 +1,1594 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct ParentalApp { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +is_allowed bool +has_is_allowed bool +} +pub fn (o &ParentalApp) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_is_allowed { +res << vproto.pack_bool_field(o.is_allowed, 2) +} + +return res +} + +pub fn parentalapp_unpack(buf []byte) ?ParentalApp { +mut res := ParentalApp{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_is_allowed = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_allowed = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_parentalapp() ParentalApp { +return ParentalApp{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_parentalapp(o ParentalApp, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_parentalapp(buf []byte, tag_wiretype vproto.WireType) ?(int, ParentalApp) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := parentalapp_unpack(v)? +return i, unpacked +} +pub struct ParentalSettings { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +applist_base_id u32 +has_applist_base_id bool +applist_base_description string +has_applist_base_description bool +applist_base []ParentalApp +applist_custom []ParentalApp +passwordhashtype u32 +has_passwordhashtype bool +salt []byte +has_salt bool +passwordhash []byte +has_passwordhash bool +is_enabled bool +has_is_enabled bool +enabled_features u32 +has_enabled_features bool +recovery_email string +has_recovery_email bool +is_site_license_lock bool +has_is_site_license_lock bool +} +pub fn (o &ParentalSettings) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_applist_base_id { +res << vproto.pack_uint32_field(o.applist_base_id, 2) +} + +if o.has_applist_base_description { +res << vproto.pack_string_field(o.applist_base_description, 3) +} + +// [packed=false] +for _, x in o.applist_base { +res << zzz_vproto_internal_pack_parentalapp(x, 4) +} + +// [packed=false] +for _, x in o.applist_custom { +res << zzz_vproto_internal_pack_parentalapp(x, 5) +} + +if o.has_passwordhashtype { +res << vproto.pack_uint32_field(o.passwordhashtype, 6) +} + +if o.has_salt { +res << vproto.pack_bytes_field(o.salt, 7) +} + +if o.has_passwordhash { +res << vproto.pack_bytes_field(o.passwordhash, 8) +} + +if o.has_is_enabled { +res << vproto.pack_bool_field(o.is_enabled, 9) +} + +if o.has_enabled_features { +res << vproto.pack_uint32_field(o.enabled_features, 10) +} + +if o.has_recovery_email { +res << vproto.pack_string_field(o.recovery_email, 11) +} + +if o.has_is_site_license_lock { +res << vproto.pack_bool_field(o.is_site_license_lock, 12) +} + +return res +} + +pub fn parentalsettings_unpack(buf []byte) ?ParentalSettings { +mut res := ParentalSettings{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_applist_base_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.applist_base_id = v +i = ii +} + +3 { +res.has_applist_base_description = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.applist_base_description = v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_parentalapp(cur_buf, tag_wiretype.wire_type)? +res.applist_base << v +i = ii +} + +5 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_parentalapp(cur_buf, tag_wiretype.wire_type)? +res.applist_custom << v +i = ii +} + +6 { +res.has_passwordhashtype = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.passwordhashtype = v +i = ii +} + +7 { +res.has_salt = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.salt = v +i = ii +} + +8 { +res.has_passwordhash = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.passwordhash = v +i = ii +} + +9 { +res.has_is_enabled = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_enabled = v +i = ii +} + +10 { +res.has_enabled_features = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.enabled_features = v +i = ii +} + +11 { +res.has_recovery_email = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.recovery_email = v +i = ii +} + +12 { +res.has_is_site_license_lock = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_site_license_lock = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_parentalsettings() ParentalSettings { +return ParentalSettings{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_parentalsettings(o ParentalSettings, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_parentalsettings(buf []byte, tag_wiretype vproto.WireType) ?(int, ParentalSettings) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := parentalsettings_unpack(v)? +return i, unpacked +} +pub struct CParentalEnableParentalSettingsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +password string +has_password bool +settings ParentalSettings +has_settings bool +sessionid string +has_sessionid bool +enablecode u32 +has_enablecode bool +steamid u64 +has_steamid bool +} +pub fn (o &CParentalEnableParentalSettingsRequest) pack() []byte { +mut res := []byte{} +if o.has_password { +res << vproto.pack_string_field(o.password, 1) +} + +if o.has_settings { +res << zzz_vproto_internal_pack_parentalsettings(o.settings, 2) +} + +if o.has_sessionid { +res << vproto.pack_string_field(o.sessionid, 3) +} + +if o.has_enablecode { +res << vproto.pack_uint32_field(o.enablecode, 4) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 10) +} + +return res +} + +pub fn cparentalenableparentalsettingsrequest_unpack(buf []byte) ?CParentalEnableParentalSettingsRequest { +mut res := CParentalEnableParentalSettingsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_password = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.password = v +i = ii +} + +2 { +res.has_settings = true +ii, v := zzz_vproto_internal_unpack_parentalsettings(cur_buf, tag_wiretype.wire_type)? +res.settings = v +i = ii +} + +3 { +res.has_sessionid = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.sessionid = v +i = ii +} + +4 { +res.has_enablecode = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.enablecode = v +i = ii +} + +10 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cparentalenableparentalsettingsrequest() CParentalEnableParentalSettingsRequest { +return CParentalEnableParentalSettingsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cparentalenableparentalsettingsrequest(o CParentalEnableParentalSettingsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cparentalenableparentalsettingsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CParentalEnableParentalSettingsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cparentalenableparentalsettingsrequest_unpack(v)? +return i, unpacked +} +pub struct CParentalEnableParentalSettingsResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CParentalEnableParentalSettingsResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cparentalenableparentalsettingsresponse_unpack(buf []byte) ?CParentalEnableParentalSettingsResponse { +res := CParentalEnableParentalSettingsResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cparentalenableparentalsettingsresponse() CParentalEnableParentalSettingsResponse { +return CParentalEnableParentalSettingsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cparentalenableparentalsettingsresponse(o CParentalEnableParentalSettingsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cparentalenableparentalsettingsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CParentalEnableParentalSettingsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cparentalenableparentalsettingsresponse_unpack(v)? +return i, unpacked +} +pub struct CParentalDisableParentalSettingsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +password string +has_password bool +steamid u64 +has_steamid bool +} +pub fn (o &CParentalDisableParentalSettingsRequest) pack() []byte { +mut res := []byte{} +if o.has_password { +res << vproto.pack_string_field(o.password, 1) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 10) +} + +return res +} + +pub fn cparentaldisableparentalsettingsrequest_unpack(buf []byte) ?CParentalDisableParentalSettingsRequest { +mut res := CParentalDisableParentalSettingsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_password = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.password = v +i = ii +} + +10 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cparentaldisableparentalsettingsrequest() CParentalDisableParentalSettingsRequest { +return CParentalDisableParentalSettingsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cparentaldisableparentalsettingsrequest(o CParentalDisableParentalSettingsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cparentaldisableparentalsettingsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CParentalDisableParentalSettingsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cparentaldisableparentalsettingsrequest_unpack(v)? +return i, unpacked +} +pub struct CParentalDisableParentalSettingsResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CParentalDisableParentalSettingsResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cparentaldisableparentalsettingsresponse_unpack(buf []byte) ?CParentalDisableParentalSettingsResponse { +res := CParentalDisableParentalSettingsResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cparentaldisableparentalsettingsresponse() CParentalDisableParentalSettingsResponse { +return CParentalDisableParentalSettingsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cparentaldisableparentalsettingsresponse(o CParentalDisableParentalSettingsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cparentaldisableparentalsettingsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CParentalDisableParentalSettingsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cparentaldisableparentalsettingsresponse_unpack(v)? +return i, unpacked +} +pub struct CParentalGetParentalSettingsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +} +pub fn (o &CParentalGetParentalSettingsRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 10) +} + +return res +} + +pub fn cparentalgetparentalsettingsrequest_unpack(buf []byte) ?CParentalGetParentalSettingsRequest { +mut res := CParentalGetParentalSettingsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +10 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cparentalgetparentalsettingsrequest() CParentalGetParentalSettingsRequest { +return CParentalGetParentalSettingsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cparentalgetparentalsettingsrequest(o CParentalGetParentalSettingsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cparentalgetparentalsettingsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CParentalGetParentalSettingsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cparentalgetparentalsettingsrequest_unpack(v)? +return i, unpacked +} +pub struct CParentalGetParentalSettingsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +settings ParentalSettings +has_settings bool +} +pub fn (o &CParentalGetParentalSettingsResponse) pack() []byte { +mut res := []byte{} +if o.has_settings { +res << zzz_vproto_internal_pack_parentalsettings(o.settings, 1) +} + +return res +} + +pub fn cparentalgetparentalsettingsresponse_unpack(buf []byte) ?CParentalGetParentalSettingsResponse { +mut res := CParentalGetParentalSettingsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_settings = true +ii, v := zzz_vproto_internal_unpack_parentalsettings(cur_buf, tag_wiretype.wire_type)? +res.settings = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cparentalgetparentalsettingsresponse() CParentalGetParentalSettingsResponse { +return CParentalGetParentalSettingsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cparentalgetparentalsettingsresponse(o CParentalGetParentalSettingsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cparentalgetparentalsettingsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CParentalGetParentalSettingsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cparentalgetparentalsettingsresponse_unpack(v)? +return i, unpacked +} +pub struct CParentalGetSignedParentalSettingsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +priority u32 +has_priority bool +} +pub fn (o &CParentalGetSignedParentalSettingsRequest) pack() []byte { +mut res := []byte{} +if o.has_priority { +res << vproto.pack_uint32_field(o.priority, 1) +} + +return res +} + +pub fn cparentalgetsignedparentalsettingsrequest_unpack(buf []byte) ?CParentalGetSignedParentalSettingsRequest { +mut res := CParentalGetSignedParentalSettingsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_priority = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.priority = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cparentalgetsignedparentalsettingsrequest() CParentalGetSignedParentalSettingsRequest { +return CParentalGetSignedParentalSettingsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cparentalgetsignedparentalsettingsrequest(o CParentalGetSignedParentalSettingsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cparentalgetsignedparentalsettingsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CParentalGetSignedParentalSettingsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cparentalgetsignedparentalsettingsrequest_unpack(v)? +return i, unpacked +} +pub struct CParentalGetSignedParentalSettingsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +serialized_settings []byte +has_serialized_settings bool +signature []byte +has_signature bool +} +pub fn (o &CParentalGetSignedParentalSettingsResponse) pack() []byte { +mut res := []byte{} +if o.has_serialized_settings { +res << vproto.pack_bytes_field(o.serialized_settings, 1) +} + +if o.has_signature { +res << vproto.pack_bytes_field(o.signature, 2) +} + +return res +} + +pub fn cparentalgetsignedparentalsettingsresponse_unpack(buf []byte) ?CParentalGetSignedParentalSettingsResponse { +mut res := CParentalGetSignedParentalSettingsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_serialized_settings = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.serialized_settings = v +i = ii +} + +2 { +res.has_signature = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.signature = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cparentalgetsignedparentalsettingsresponse() CParentalGetSignedParentalSettingsResponse { +return CParentalGetSignedParentalSettingsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cparentalgetsignedparentalsettingsresponse(o CParentalGetSignedParentalSettingsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cparentalgetsignedparentalsettingsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CParentalGetSignedParentalSettingsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cparentalgetsignedparentalsettingsresponse_unpack(v)? +return i, unpacked +} +pub struct CParentalSetParentalSettingsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +password string +has_password bool +settings ParentalSettings +has_settings bool +new_password string +has_new_password bool +sessionid string +has_sessionid bool +steamid u64 +has_steamid bool +} +pub fn (o &CParentalSetParentalSettingsRequest) pack() []byte { +mut res := []byte{} +if o.has_password { +res << vproto.pack_string_field(o.password, 1) +} + +if o.has_settings { +res << zzz_vproto_internal_pack_parentalsettings(o.settings, 2) +} + +if o.has_new_password { +res << vproto.pack_string_field(o.new_password, 3) +} + +if o.has_sessionid { +res << vproto.pack_string_field(o.sessionid, 4) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 10) +} + +return res +} + +pub fn cparentalsetparentalsettingsrequest_unpack(buf []byte) ?CParentalSetParentalSettingsRequest { +mut res := CParentalSetParentalSettingsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_password = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.password = v +i = ii +} + +2 { +res.has_settings = true +ii, v := zzz_vproto_internal_unpack_parentalsettings(cur_buf, tag_wiretype.wire_type)? +res.settings = v +i = ii +} + +3 { +res.has_new_password = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.new_password = v +i = ii +} + +4 { +res.has_sessionid = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.sessionid = v +i = ii +} + +10 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cparentalsetparentalsettingsrequest() CParentalSetParentalSettingsRequest { +return CParentalSetParentalSettingsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cparentalsetparentalsettingsrequest(o CParentalSetParentalSettingsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cparentalsetparentalsettingsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CParentalSetParentalSettingsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cparentalsetparentalsettingsrequest_unpack(v)? +return i, unpacked +} +pub struct CParentalSetParentalSettingsResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CParentalSetParentalSettingsResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cparentalsetparentalsettingsresponse_unpack(buf []byte) ?CParentalSetParentalSettingsResponse { +res := CParentalSetParentalSettingsResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cparentalsetparentalsettingsresponse() CParentalSetParentalSettingsResponse { +return CParentalSetParentalSettingsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cparentalsetparentalsettingsresponse(o CParentalSetParentalSettingsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cparentalsetparentalsettingsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CParentalSetParentalSettingsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cparentalsetparentalsettingsresponse_unpack(v)? +return i, unpacked +} +pub struct CParentalValidateTokenRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +unlock_token string +has_unlock_token bool +} +pub fn (o &CParentalValidateTokenRequest) pack() []byte { +mut res := []byte{} +if o.has_unlock_token { +res << vproto.pack_string_field(o.unlock_token, 1) +} + +return res +} + +pub fn cparentalvalidatetokenrequest_unpack(buf []byte) ?CParentalValidateTokenRequest { +mut res := CParentalValidateTokenRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_unlock_token = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.unlock_token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cparentalvalidatetokenrequest() CParentalValidateTokenRequest { +return CParentalValidateTokenRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cparentalvalidatetokenrequest(o CParentalValidateTokenRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cparentalvalidatetokenrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CParentalValidateTokenRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cparentalvalidatetokenrequest_unpack(v)? +return i, unpacked +} +pub struct CParentalValidateTokenResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CParentalValidateTokenResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cparentalvalidatetokenresponse_unpack(buf []byte) ?CParentalValidateTokenResponse { +res := CParentalValidateTokenResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cparentalvalidatetokenresponse() CParentalValidateTokenResponse { +return CParentalValidateTokenResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cparentalvalidatetokenresponse(o CParentalValidateTokenResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cparentalvalidatetokenresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CParentalValidateTokenResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cparentalvalidatetokenresponse_unpack(v)? +return i, unpacked +} +pub struct CParentalValidatePasswordRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +password string +has_password bool +session string +has_session bool +send_unlock_on_success bool +has_send_unlock_on_success bool +} +pub fn (o &CParentalValidatePasswordRequest) pack() []byte { +mut res := []byte{} +if o.has_password { +res << vproto.pack_string_field(o.password, 1) +} + +if o.has_session { +res << vproto.pack_string_field(o.session, 2) +} + +if o.has_send_unlock_on_success { +res << vproto.pack_bool_field(o.send_unlock_on_success, 3) +} + +return res +} + +pub fn cparentalvalidatepasswordrequest_unpack(buf []byte) ?CParentalValidatePasswordRequest { +mut res := CParentalValidatePasswordRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_password = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.password = v +i = ii +} + +2 { +res.has_session = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.session = v +i = ii +} + +3 { +res.has_send_unlock_on_success = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.send_unlock_on_success = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cparentalvalidatepasswordrequest() CParentalValidatePasswordRequest { +return CParentalValidatePasswordRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cparentalvalidatepasswordrequest(o CParentalValidatePasswordRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cparentalvalidatepasswordrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CParentalValidatePasswordRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cparentalvalidatepasswordrequest_unpack(v)? +return i, unpacked +} +pub struct CParentalValidatePasswordResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +token string +has_token bool +} +pub fn (o &CParentalValidatePasswordResponse) pack() []byte { +mut res := []byte{} +if o.has_token { +res << vproto.pack_string_field(o.token, 1) +} + +return res +} + +pub fn cparentalvalidatepasswordresponse_unpack(buf []byte) ?CParentalValidatePasswordResponse { +mut res := CParentalValidatePasswordResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_token = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cparentalvalidatepasswordresponse() CParentalValidatePasswordResponse { +return CParentalValidatePasswordResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cparentalvalidatepasswordresponse(o CParentalValidatePasswordResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cparentalvalidatepasswordresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CParentalValidatePasswordResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cparentalvalidatepasswordresponse_unpack(v)? +return i, unpacked +} +pub struct CParentalLockClientRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +session string +has_session bool +} +pub fn (o &CParentalLockClientRequest) pack() []byte { +mut res := []byte{} +if o.has_session { +res << vproto.pack_string_field(o.session, 1) +} + +return res +} + +pub fn cparentallockclientrequest_unpack(buf []byte) ?CParentalLockClientRequest { +mut res := CParentalLockClientRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_session = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.session = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cparentallockclientrequest() CParentalLockClientRequest { +return CParentalLockClientRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cparentallockclientrequest(o CParentalLockClientRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cparentallockclientrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CParentalLockClientRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cparentallockclientrequest_unpack(v)? +return i, unpacked +} +pub struct CParentalLockClientResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CParentalLockClientResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cparentallockclientresponse_unpack(buf []byte) ?CParentalLockClientResponse { +res := CParentalLockClientResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cparentallockclientresponse() CParentalLockClientResponse { +return CParentalLockClientResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cparentallockclientresponse(o CParentalLockClientResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cparentallockclientresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CParentalLockClientResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cparentallockclientresponse_unpack(v)? +return i, unpacked +} +pub struct CParentalRequestRecoveryCodeRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CParentalRequestRecoveryCodeRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn cparentalrequestrecoverycoderequest_unpack(buf []byte) ?CParentalRequestRecoveryCodeRequest { +res := CParentalRequestRecoveryCodeRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cparentalrequestrecoverycoderequest() CParentalRequestRecoveryCodeRequest { +return CParentalRequestRecoveryCodeRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cparentalrequestrecoverycoderequest(o CParentalRequestRecoveryCodeRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cparentalrequestrecoverycoderequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CParentalRequestRecoveryCodeRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cparentalrequestrecoverycoderequest_unpack(v)? +return i, unpacked +} +pub struct CParentalRequestRecoveryCodeResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CParentalRequestRecoveryCodeResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cparentalrequestrecoverycoderesponse_unpack(buf []byte) ?CParentalRequestRecoveryCodeResponse { +res := CParentalRequestRecoveryCodeResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cparentalrequestrecoverycoderesponse() CParentalRequestRecoveryCodeResponse { +return CParentalRequestRecoveryCodeResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cparentalrequestrecoverycoderesponse(o CParentalRequestRecoveryCodeResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cparentalrequestrecoverycoderesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CParentalRequestRecoveryCodeResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cparentalrequestrecoverycoderesponse_unpack(v)? +return i, unpacked +} +pub struct CParentalDisableWithRecoveryCodeRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +recovery_code u32 +has_recovery_code bool +steamid u64 +has_steamid bool +} +pub fn (o &CParentalDisableWithRecoveryCodeRequest) pack() []byte { +mut res := []byte{} +if o.has_recovery_code { +res << vproto.pack_uint32_field(o.recovery_code, 1) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 10) +} + +return res +} + +pub fn cparentaldisablewithrecoverycoderequest_unpack(buf []byte) ?CParentalDisableWithRecoveryCodeRequest { +mut res := CParentalDisableWithRecoveryCodeRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_recovery_code = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.recovery_code = v +i = ii +} + +10 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cparentaldisablewithrecoverycoderequest() CParentalDisableWithRecoveryCodeRequest { +return CParentalDisableWithRecoveryCodeRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cparentaldisablewithrecoverycoderequest(o CParentalDisableWithRecoveryCodeRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cparentaldisablewithrecoverycoderequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CParentalDisableWithRecoveryCodeRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cparentaldisablewithrecoverycoderequest_unpack(v)? +return i, unpacked +} +pub struct CParentalDisableWithRecoveryCodeResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CParentalDisableWithRecoveryCodeResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cparentaldisablewithrecoverycoderesponse_unpack(buf []byte) ?CParentalDisableWithRecoveryCodeResponse { +res := CParentalDisableWithRecoveryCodeResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cparentaldisablewithrecoverycoderesponse() CParentalDisableWithRecoveryCodeResponse { +return CParentalDisableWithRecoveryCodeResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cparentaldisablewithrecoverycoderesponse(o CParentalDisableWithRecoveryCodeResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cparentaldisablewithrecoverycoderesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CParentalDisableWithRecoveryCodeResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cparentaldisablewithrecoverycoderesponse_unpack(v)? +return i, unpacked +} +pub struct CParentalParentalSettingsChangeNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +serialized_settings []byte +has_serialized_settings bool +signature []byte +has_signature bool +password string +has_password bool +sessionid string +has_sessionid bool +} +pub fn (o &CParentalParentalSettingsChangeNotification) pack() []byte { +mut res := []byte{} +if o.has_serialized_settings { +res << vproto.pack_bytes_field(o.serialized_settings, 1) +} + +if o.has_signature { +res << vproto.pack_bytes_field(o.signature, 2) +} + +if o.has_password { +res << vproto.pack_string_field(o.password, 3) +} + +if o.has_sessionid { +res << vproto.pack_string_field(o.sessionid, 4) +} + +return res +} + +pub fn cparentalparentalsettingschangenotification_unpack(buf []byte) ?CParentalParentalSettingsChangeNotification { +mut res := CParentalParentalSettingsChangeNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_serialized_settings = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.serialized_settings = v +i = ii +} + +2 { +res.has_signature = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.signature = v +i = ii +} + +3 { +res.has_password = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.password = v +i = ii +} + +4 { +res.has_sessionid = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.sessionid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cparentalparentalsettingschangenotification() CParentalParentalSettingsChangeNotification { +return CParentalParentalSettingsChangeNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cparentalparentalsettingschangenotification(o CParentalParentalSettingsChangeNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cparentalparentalsettingschangenotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CParentalParentalSettingsChangeNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cparentalparentalsettingschangenotification_unpack(v)? +return i, unpacked +} +pub struct CParentalParentalUnlockNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +password string +has_password bool +sessionid string +has_sessionid bool +} +pub fn (o &CParentalParentalUnlockNotification) pack() []byte { +mut res := []byte{} +if o.has_password { +res << vproto.pack_string_field(o.password, 1) +} + +if o.has_sessionid { +res << vproto.pack_string_field(o.sessionid, 2) +} + +return res +} + +pub fn cparentalparentalunlocknotification_unpack(buf []byte) ?CParentalParentalUnlockNotification { +mut res := CParentalParentalUnlockNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_password = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.password = v +i = ii +} + +2 { +res.has_sessionid = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.sessionid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cparentalparentalunlocknotification() CParentalParentalUnlockNotification { +return CParentalParentalUnlockNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cparentalparentalunlocknotification(o CParentalParentalUnlockNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cparentalparentalunlocknotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CParentalParentalUnlockNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cparentalparentalunlocknotification_unpack(v)? +return i, unpacked +} +pub struct CParentalParentalLockNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +sessionid string +has_sessionid bool +} +pub fn (o &CParentalParentalLockNotification) pack() []byte { +mut res := []byte{} +if o.has_sessionid { +res << vproto.pack_string_field(o.sessionid, 1) +} + +return res +} + +pub fn cparentalparentallocknotification_unpack(buf []byte) ?CParentalParentalLockNotification { +mut res := CParentalParentalLockNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_sessionid = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.sessionid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cparentalparentallocknotification() CParentalParentalLockNotification { +return CParentalParentalLockNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cparentalparentallocknotification(o CParentalParentalLockNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cparentalparentallocknotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CParentalParentalLockNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cparentalparentallocknotification_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_parties.steamclient_pb.v b/proto/steammessages_parties.steamclient_pb.v new file mode 100644 index 0000000..fec342b --- /dev/null +++ b/proto/steammessages_parties.steamclient_pb.v @@ -0,0 +1,891 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CPartiesJoinPartyRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +beacon_id u64 +has_beacon_id bool +} +pub fn (o &CPartiesJoinPartyRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_beacon_id { +res << vproto.pack_uint64_field(o.beacon_id, 2) +} + +return res +} + +pub fn cpartiesjoinpartyrequest_unpack(buf []byte) ?CPartiesJoinPartyRequest { +mut res := CPartiesJoinPartyRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_beacon_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.beacon_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartiesjoinpartyrequest() CPartiesJoinPartyRequest { +return CPartiesJoinPartyRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartiesjoinpartyrequest(o CPartiesJoinPartyRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartiesjoinpartyrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartiesJoinPartyRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartiesjoinpartyrequest_unpack(v)? +return i, unpacked +} +pub struct CPartiesJoinPartyResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +beacon_id u64 +has_beacon_id bool +connect_string string +has_connect_string bool +} +pub fn (o &CPartiesJoinPartyResponse) pack() []byte { +mut res := []byte{} +if o.has_beacon_id { +res << vproto.pack_uint64_field(o.beacon_id, 1) +} + +if o.has_connect_string { +res << vproto.pack_string_field(o.connect_string, 2) +} + +return res +} + +pub fn cpartiesjoinpartyresponse_unpack(buf []byte) ?CPartiesJoinPartyResponse { +mut res := CPartiesJoinPartyResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_beacon_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.beacon_id = v +i = ii +} + +2 { +res.has_connect_string = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.connect_string = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartiesjoinpartyresponse() CPartiesJoinPartyResponse { +return CPartiesJoinPartyResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartiesjoinpartyresponse(o CPartiesJoinPartyResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartiesjoinpartyresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartiesJoinPartyResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartiesjoinpartyresponse_unpack(v)? +return i, unpacked +} +pub struct CPartiesBeaconLocation { +mut: +unknown_fields []vproto.UnknownField +pub mut: +location_type u32 +has_location_type bool +location_id u64 +has_location_id bool +} +pub fn (o &CPartiesBeaconLocation) pack() []byte { +mut res := []byte{} +if o.has_location_type { +res << vproto.pack_uint32_field(o.location_type, 1) +} + +if o.has_location_id { +res << vproto.pack_uint64_field(o.location_id, 2) +} + +return res +} + +pub fn cpartiesbeaconlocation_unpack(buf []byte) ?CPartiesBeaconLocation { +mut res := CPartiesBeaconLocation{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_location_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.location_type = v +i = ii +} + +2 { +res.has_location_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.location_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartiesbeaconlocation() CPartiesBeaconLocation { +return CPartiesBeaconLocation{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartiesbeaconlocation(o CPartiesBeaconLocation, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartiesbeaconlocation(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartiesBeaconLocation) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartiesbeaconlocation_unpack(v)? +return i, unpacked +} +pub struct CPartiesCreateBeaconRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +num_open_slots u32 +has_num_open_slots bool +locations []CPartiesBeaconLocation +connect_string string +has_connect_string bool +metadata string +has_metadata bool +} +pub fn (o &CPartiesCreateBeaconRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_num_open_slots { +res << vproto.pack_uint32_field(o.num_open_slots, 2) +} + +// [packed=false] +for _, x in o.locations { +res << zzz_vproto_internal_pack_cpartiesbeaconlocation(x, 3) +} + +if o.has_connect_string { +res << vproto.pack_string_field(o.connect_string, 4) +} + +if o.has_metadata { +res << vproto.pack_string_field(o.metadata, 5) +} + +return res +} + +pub fn cpartiescreatebeaconrequest_unpack(buf []byte) ?CPartiesCreateBeaconRequest { +mut res := CPartiesCreateBeaconRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_num_open_slots = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.num_open_slots = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cpartiesbeaconlocation(cur_buf, tag_wiretype.wire_type)? +res.locations << v +i = ii +} + +4 { +res.has_connect_string = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.connect_string = v +i = ii +} + +5 { +res.has_metadata = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.metadata = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartiescreatebeaconrequest() CPartiesCreateBeaconRequest { +return CPartiesCreateBeaconRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartiescreatebeaconrequest(o CPartiesCreateBeaconRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartiescreatebeaconrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartiesCreateBeaconRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartiescreatebeaconrequest_unpack(v)? +return i, unpacked +} +pub struct CPartiesCreateBeaconResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +beacon_id u64 +has_beacon_id bool +} +pub fn (o &CPartiesCreateBeaconResponse) pack() []byte { +mut res := []byte{} +if o.has_beacon_id { +res << vproto.pack_uint64_field(o.beacon_id, 1) +} + +return res +} + +pub fn cpartiescreatebeaconresponse_unpack(buf []byte) ?CPartiesCreateBeaconResponse { +mut res := CPartiesCreateBeaconResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_beacon_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.beacon_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartiescreatebeaconresponse() CPartiesCreateBeaconResponse { +return CPartiesCreateBeaconResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartiescreatebeaconresponse(o CPartiesCreateBeaconResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartiescreatebeaconresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartiesCreateBeaconResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartiescreatebeaconresponse_unpack(v)? +return i, unpacked +} +pub struct CPartiesOnReservationCompletedRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +beacon_id u64 +has_beacon_id bool +user_steamid u64 +has_user_steamid bool +} +pub fn (o &CPartiesOnReservationCompletedRequest) pack() []byte { +mut res := []byte{} +if o.has_beacon_id { +res << vproto.pack_uint64_field(o.beacon_id, 1) +} + +if o.has_user_steamid { +res << vproto.pack_64bit_field(o.user_steamid, 2) +} + +return res +} + +pub fn cpartiesonreservationcompletedrequest_unpack(buf []byte) ?CPartiesOnReservationCompletedRequest { +mut res := CPartiesOnReservationCompletedRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_beacon_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.beacon_id = v +i = ii +} + +2 { +res.has_user_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.user_steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartiesonreservationcompletedrequest() CPartiesOnReservationCompletedRequest { +return CPartiesOnReservationCompletedRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartiesonreservationcompletedrequest(o CPartiesOnReservationCompletedRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartiesonreservationcompletedrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartiesOnReservationCompletedRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartiesonreservationcompletedrequest_unpack(v)? +return i, unpacked +} +pub struct CPartiesOnReservationCompletedResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +beacon_id u64 +has_beacon_id bool +} +pub fn (o &CPartiesOnReservationCompletedResponse) pack() []byte { +mut res := []byte{} +if o.has_beacon_id { +res << vproto.pack_uint64_field(o.beacon_id, 1) +} + +return res +} + +pub fn cpartiesonreservationcompletedresponse_unpack(buf []byte) ?CPartiesOnReservationCompletedResponse { +mut res := CPartiesOnReservationCompletedResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_beacon_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.beacon_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartiesonreservationcompletedresponse() CPartiesOnReservationCompletedResponse { +return CPartiesOnReservationCompletedResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartiesonreservationcompletedresponse(o CPartiesOnReservationCompletedResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartiesonreservationcompletedresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartiesOnReservationCompletedResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartiesonreservationcompletedresponse_unpack(v)? +return i, unpacked +} +pub struct CPartiesCancelReservationRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +beacon_id u64 +has_beacon_id bool +user_steamid u64 +has_user_steamid bool +} +pub fn (o &CPartiesCancelReservationRequest) pack() []byte { +mut res := []byte{} +if o.has_beacon_id { +res << vproto.pack_uint64_field(o.beacon_id, 1) +} + +if o.has_user_steamid { +res << vproto.pack_64bit_field(o.user_steamid, 2) +} + +return res +} + +pub fn cpartiescancelreservationrequest_unpack(buf []byte) ?CPartiesCancelReservationRequest { +mut res := CPartiesCancelReservationRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_beacon_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.beacon_id = v +i = ii +} + +2 { +res.has_user_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.user_steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartiescancelreservationrequest() CPartiesCancelReservationRequest { +return CPartiesCancelReservationRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartiescancelreservationrequest(o CPartiesCancelReservationRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartiescancelreservationrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartiesCancelReservationRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartiescancelreservationrequest_unpack(v)? +return i, unpacked +} +pub struct CPartiesCancelReservationResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +beacon_id u64 +has_beacon_id bool +} +pub fn (o &CPartiesCancelReservationResponse) pack() []byte { +mut res := []byte{} +if o.has_beacon_id { +res << vproto.pack_uint64_field(o.beacon_id, 1) +} + +return res +} + +pub fn cpartiescancelreservationresponse_unpack(buf []byte) ?CPartiesCancelReservationResponse { +mut res := CPartiesCancelReservationResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_beacon_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.beacon_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartiescancelreservationresponse() CPartiesCancelReservationResponse { +return CPartiesCancelReservationResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartiescancelreservationresponse(o CPartiesCancelReservationResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartiescancelreservationresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartiesCancelReservationResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartiescancelreservationresponse_unpack(v)? +return i, unpacked +} +pub struct CPartiesChangeNumOpenSlotsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +beacon_id u64 +has_beacon_id bool +num_open_slots u32 +has_num_open_slots bool +} +pub fn (o &CPartiesChangeNumOpenSlotsRequest) pack() []byte { +mut res := []byte{} +if o.has_beacon_id { +res << vproto.pack_uint64_field(o.beacon_id, 1) +} + +if o.has_num_open_slots { +res << vproto.pack_uint32_field(o.num_open_slots, 2) +} + +return res +} + +pub fn cpartieschangenumopenslotsrequest_unpack(buf []byte) ?CPartiesChangeNumOpenSlotsRequest { +mut res := CPartiesChangeNumOpenSlotsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_beacon_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.beacon_id = v +i = ii +} + +2 { +res.has_num_open_slots = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.num_open_slots = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartieschangenumopenslotsrequest() CPartiesChangeNumOpenSlotsRequest { +return CPartiesChangeNumOpenSlotsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartieschangenumopenslotsrequest(o CPartiesChangeNumOpenSlotsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartieschangenumopenslotsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartiesChangeNumOpenSlotsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartieschangenumopenslotsrequest_unpack(v)? +return i, unpacked +} +pub struct CPartiesChangeNumOpenSlotsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +beacon_id u64 +has_beacon_id bool +} +pub fn (o &CPartiesChangeNumOpenSlotsResponse) pack() []byte { +mut res := []byte{} +if o.has_beacon_id { +res << vproto.pack_uint64_field(o.beacon_id, 1) +} + +return res +} + +pub fn cpartieschangenumopenslotsresponse_unpack(buf []byte) ?CPartiesChangeNumOpenSlotsResponse { +mut res := CPartiesChangeNumOpenSlotsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_beacon_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.beacon_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartieschangenumopenslotsresponse() CPartiesChangeNumOpenSlotsResponse { +return CPartiesChangeNumOpenSlotsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartieschangenumopenslotsresponse(o CPartiesChangeNumOpenSlotsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartieschangenumopenslotsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartiesChangeNumOpenSlotsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartieschangenumopenslotsresponse_unpack(v)? +return i, unpacked +} +pub struct CPartiesDestroyBeaconRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +beacon_id u64 +has_beacon_id bool +} +pub fn (o &CPartiesDestroyBeaconRequest) pack() []byte { +mut res := []byte{} +if o.has_beacon_id { +res << vproto.pack_uint64_field(o.beacon_id, 1) +} + +return res +} + +pub fn cpartiesdestroybeaconrequest_unpack(buf []byte) ?CPartiesDestroyBeaconRequest { +mut res := CPartiesDestroyBeaconRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_beacon_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.beacon_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartiesdestroybeaconrequest() CPartiesDestroyBeaconRequest { +return CPartiesDestroyBeaconRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartiesdestroybeaconrequest(o CPartiesDestroyBeaconRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartiesdestroybeaconrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartiesDestroyBeaconRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartiesdestroybeaconrequest_unpack(v)? +return i, unpacked +} +pub struct CPartiesDestroyBeaconResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +beacon_id u64 +has_beacon_id bool +} +pub fn (o &CPartiesDestroyBeaconResponse) pack() []byte { +mut res := []byte{} +if o.has_beacon_id { +res << vproto.pack_uint64_field(o.beacon_id, 1) +} + +return res +} + +pub fn cpartiesdestroybeaconresponse_unpack(buf []byte) ?CPartiesDestroyBeaconResponse { +mut res := CPartiesDestroyBeaconResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_beacon_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.beacon_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartiesdestroybeaconresponse() CPartiesDestroyBeaconResponse { +return CPartiesDestroyBeaconResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartiesdestroybeaconresponse(o CPartiesDestroyBeaconResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartiesdestroybeaconresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartiesDestroyBeaconResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartiesdestroybeaconresponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_partnerapps.steamclient_pb.v b/proto/steammessages_partnerapps.steamclient_pb.v new file mode 100644 index 0000000..bcd57da --- /dev/null +++ b/proto/steammessages_partnerapps.steamclient_pb.v @@ -0,0 +1,1187 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CPartnerAppsRequestUploadTokenRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +filename string +has_filename bool +appid u32 +has_appid bool +} +pub fn (o &CPartnerAppsRequestUploadTokenRequest) pack() []byte { +mut res := []byte{} +if o.has_filename { +res << vproto.pack_string_field(o.filename, 1) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 2) +} + +return res +} + +pub fn cpartnerappsrequestuploadtokenrequest_unpack(buf []byte) ?CPartnerAppsRequestUploadTokenRequest { +mut res := CPartnerAppsRequestUploadTokenRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.filename = v +i = ii +} + +2 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartnerappsrequestuploadtokenrequest() CPartnerAppsRequestUploadTokenRequest { +return CPartnerAppsRequestUploadTokenRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartnerappsrequestuploadtokenrequest(o CPartnerAppsRequestUploadTokenRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartnerappsrequestuploadtokenrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartnerAppsRequestUploadTokenRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartnerappsrequestuploadtokenrequest_unpack(v)? +return i, unpacked +} +pub struct CPartnerAppsRequestUploadTokenResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +upload_token u64 +has_upload_token bool +location string +has_location bool +routing_id u64 +has_routing_id bool +} +pub fn (o &CPartnerAppsRequestUploadTokenResponse) pack() []byte { +mut res := []byte{} +if o.has_upload_token { +res << vproto.pack_uint64_field(o.upload_token, 1) +} + +if o.has_location { +res << vproto.pack_string_field(o.location, 2) +} + +if o.has_routing_id { +res << vproto.pack_uint64_field(o.routing_id, 3) +} + +return res +} + +pub fn cpartnerappsrequestuploadtokenresponse_unpack(buf []byte) ?CPartnerAppsRequestUploadTokenResponse { +mut res := CPartnerAppsRequestUploadTokenResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_upload_token = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.upload_token = v +i = ii +} + +2 { +res.has_location = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.location = v +i = ii +} + +3 { +res.has_routing_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.routing_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartnerappsrequestuploadtokenresponse() CPartnerAppsRequestUploadTokenResponse { +return CPartnerAppsRequestUploadTokenResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartnerappsrequestuploadtokenresponse(o CPartnerAppsRequestUploadTokenResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartnerappsrequestuploadtokenresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartnerAppsRequestUploadTokenResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartnerappsrequestuploadtokenresponse_unpack(v)? +return i, unpacked +} +pub struct CPartnerAppsFinishUploadRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +upload_token u64 +has_upload_token bool +routing_id u64 +has_routing_id bool +app_id u32 +has_app_id bool +} +pub fn (o &CPartnerAppsFinishUploadRequest) pack() []byte { +mut res := []byte{} +if o.has_upload_token { +res << vproto.pack_uint64_field(o.upload_token, 1) +} + +if o.has_routing_id { +res << vproto.pack_uint64_field(o.routing_id, 2) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 3) +} + +return res +} + +pub fn cpartnerappsfinishuploadrequest_unpack(buf []byte) ?CPartnerAppsFinishUploadRequest { +mut res := CPartnerAppsFinishUploadRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_upload_token = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.upload_token = v +i = ii +} + +2 { +res.has_routing_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.routing_id = v +i = ii +} + +3 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartnerappsfinishuploadrequest() CPartnerAppsFinishUploadRequest { +return CPartnerAppsFinishUploadRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartnerappsfinishuploadrequest(o CPartnerAppsFinishUploadRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartnerappsfinishuploadrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartnerAppsFinishUploadRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartnerappsfinishuploadrequest_unpack(v)? +return i, unpacked +} +pub struct CPartnerAppsFinishUploadKVsignResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +signed_installscript string +has_signed_installscript bool +} +pub fn (o &CPartnerAppsFinishUploadKVsignResponse) pack() []byte { +mut res := []byte{} +if o.has_signed_installscript { +res << vproto.pack_string_field(o.signed_installscript, 1) +} + +return res +} + +pub fn cpartnerappsfinishuploadkvsignresponse_unpack(buf []byte) ?CPartnerAppsFinishUploadKVsignResponse { +mut res := CPartnerAppsFinishUploadKVsignResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_signed_installscript = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.signed_installscript = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartnerappsfinishuploadkvsignresponse() CPartnerAppsFinishUploadKVsignResponse { +return CPartnerAppsFinishUploadKVsignResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartnerappsfinishuploadkvsignresponse(o CPartnerAppsFinishUploadKVsignResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartnerappsfinishuploadkvsignresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartnerAppsFinishUploadKVsignResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartnerappsfinishuploadkvsignresponse_unpack(v)? +return i, unpacked +} +pub struct CPartnerAppsFinishUploadLegacyDRmrequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +upload_token u64 +has_upload_token bool +routing_id u64 +has_routing_id bool +app_id u32 +has_app_id bool +flags u32 +has_flags bool +tool_name string +has_tool_name bool +} +pub fn (o &CPartnerAppsFinishUploadLegacyDRmrequest) pack() []byte { +mut res := []byte{} +if o.has_upload_token { +res << vproto.pack_uint64_field(o.upload_token, 1) +} + +if o.has_routing_id { +res << vproto.pack_uint64_field(o.routing_id, 2) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 3) +} + +if o.has_flags { +res << vproto.pack_uint32_field(o.flags, 4) +} + +if o.has_tool_name { +res << vproto.pack_string_field(o.tool_name, 5) +} + +return res +} + +pub fn cpartnerappsfinishuploadlegacydrmrequest_unpack(buf []byte) ?CPartnerAppsFinishUploadLegacyDRmrequest { +mut res := CPartnerAppsFinishUploadLegacyDRmrequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_upload_token = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.upload_token = v +i = ii +} + +2 { +res.has_routing_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.routing_id = v +i = ii +} + +3 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +4 { +res.has_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.flags = v +i = ii +} + +5 { +res.has_tool_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.tool_name = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartnerappsfinishuploadlegacydrmrequest() CPartnerAppsFinishUploadLegacyDRmrequest { +return CPartnerAppsFinishUploadLegacyDRmrequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartnerappsfinishuploadlegacydrmrequest(o CPartnerAppsFinishUploadLegacyDRmrequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartnerappsfinishuploadlegacydrmrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartnerAppsFinishUploadLegacyDRmrequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartnerappsfinishuploadlegacydrmrequest_unpack(v)? +return i, unpacked +} +pub struct CPartnerAppsFinishUploadLegacyDRmresponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +file_id string +has_file_id bool +} +pub fn (o &CPartnerAppsFinishUploadLegacyDRmresponse) pack() []byte { +mut res := []byte{} +if o.has_file_id { +res << vproto.pack_string_field(o.file_id, 1) +} + +return res +} + +pub fn cpartnerappsfinishuploadlegacydrmresponse_unpack(buf []byte) ?CPartnerAppsFinishUploadLegacyDRmresponse { +mut res := CPartnerAppsFinishUploadLegacyDRmresponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_file_id = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.file_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartnerappsfinishuploadlegacydrmresponse() CPartnerAppsFinishUploadLegacyDRmresponse { +return CPartnerAppsFinishUploadLegacyDRmresponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartnerappsfinishuploadlegacydrmresponse(o CPartnerAppsFinishUploadLegacyDRmresponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartnerappsfinishuploadlegacydrmresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartnerAppsFinishUploadLegacyDRmresponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartnerappsfinishuploadlegacydrmresponse_unpack(v)? +return i, unpacked +} +pub struct CPartnerAppsFinishUploadResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPartnerAppsFinishUploadResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cpartnerappsfinishuploadresponse_unpack(buf []byte) ?CPartnerAppsFinishUploadResponse { +res := CPartnerAppsFinishUploadResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartnerappsfinishuploadresponse() CPartnerAppsFinishUploadResponse { +return CPartnerAppsFinishUploadResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartnerappsfinishuploadresponse(o CPartnerAppsFinishUploadResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartnerappsfinishuploadresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartnerAppsFinishUploadResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartnerappsfinishuploadresponse_unpack(v)? +return i, unpacked +} +pub struct CPartnerAppsFinishUploadDepotRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +upload_token u64 +has_upload_token bool +routing_id u64 +has_routing_id bool +app_id u32 +has_app_id bool +depot_id u32 +has_depot_id bool +build_flags u32 +has_build_flags bool +} +pub fn (o &CPartnerAppsFinishUploadDepotRequest) pack() []byte { +mut res := []byte{} +if o.has_upload_token { +res << vproto.pack_uint64_field(o.upload_token, 1) +} + +if o.has_routing_id { +res << vproto.pack_uint64_field(o.routing_id, 2) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 3) +} + +if o.has_depot_id { +res << vproto.pack_uint32_field(o.depot_id, 4) +} + +if o.has_build_flags { +res << vproto.pack_uint32_field(o.build_flags, 5) +} + +return res +} + +pub fn cpartnerappsfinishuploaddepotrequest_unpack(buf []byte) ?CPartnerAppsFinishUploadDepotRequest { +mut res := CPartnerAppsFinishUploadDepotRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_upload_token = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.upload_token = v +i = ii +} + +2 { +res.has_routing_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.routing_id = v +i = ii +} + +3 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +4 { +res.has_depot_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.depot_id = v +i = ii +} + +5 { +res.has_build_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.build_flags = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartnerappsfinishuploaddepotrequest() CPartnerAppsFinishUploadDepotRequest { +return CPartnerAppsFinishUploadDepotRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartnerappsfinishuploaddepotrequest(o CPartnerAppsFinishUploadDepotRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartnerappsfinishuploaddepotrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartnerAppsFinishUploadDepotRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartnerappsfinishuploaddepotrequest_unpack(v)? +return i, unpacked +} +pub struct CPartnerAppsFinishUploadDepotResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPartnerAppsFinishUploadDepotResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cpartnerappsfinishuploaddepotresponse_unpack(buf []byte) ?CPartnerAppsFinishUploadDepotResponse { +res := CPartnerAppsFinishUploadDepotResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartnerappsfinishuploaddepotresponse() CPartnerAppsFinishUploadDepotResponse { +return CPartnerAppsFinishUploadDepotResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartnerappsfinishuploaddepotresponse(o CPartnerAppsFinishUploadDepotResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartnerappsfinishuploaddepotresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartnerAppsFinishUploadDepotResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartnerappsfinishuploaddepotresponse_unpack(v)? +return i, unpacked +} +pub struct CPartnerAppsGetDepotBuildResultRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +upload_token u64 +has_upload_token bool +routing_id u64 +has_routing_id bool +} +pub fn (o &CPartnerAppsGetDepotBuildResultRequest) pack() []byte { +mut res := []byte{} +if o.has_upload_token { +res << vproto.pack_uint64_field(o.upload_token, 1) +} + +if o.has_routing_id { +res << vproto.pack_uint64_field(o.routing_id, 2) +} + +return res +} + +pub fn cpartnerappsgetdepotbuildresultrequest_unpack(buf []byte) ?CPartnerAppsGetDepotBuildResultRequest { +mut res := CPartnerAppsGetDepotBuildResultRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_upload_token = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.upload_token = v +i = ii +} + +2 { +res.has_routing_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.routing_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartnerappsgetdepotbuildresultrequest() CPartnerAppsGetDepotBuildResultRequest { +return CPartnerAppsGetDepotBuildResultRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartnerappsgetdepotbuildresultrequest(o CPartnerAppsGetDepotBuildResultRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartnerappsgetdepotbuildresultrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartnerAppsGetDepotBuildResultRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartnerappsgetdepotbuildresultrequest_unpack(v)? +return i, unpacked +} +pub struct CPartnerAppsGetDepotBuildResultResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +manifest_id u64 +has_manifest_id bool +error_msg string +has_error_msg bool +} +pub fn (o &CPartnerAppsGetDepotBuildResultResponse) pack() []byte { +mut res := []byte{} +if o.has_manifest_id { +res << vproto.pack_uint64_field(o.manifest_id, 1) +} + +if o.has_error_msg { +res << vproto.pack_string_field(o.error_msg, 2) +} + +return res +} + +pub fn cpartnerappsgetdepotbuildresultresponse_unpack(buf []byte) ?CPartnerAppsGetDepotBuildResultResponse { +mut res := CPartnerAppsGetDepotBuildResultResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_manifest_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.manifest_id = v +i = ii +} + +2 { +res.has_error_msg = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.error_msg = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartnerappsgetdepotbuildresultresponse() CPartnerAppsGetDepotBuildResultResponse { +return CPartnerAppsGetDepotBuildResultResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartnerappsgetdepotbuildresultresponse(o CPartnerAppsGetDepotBuildResultResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartnerappsgetdepotbuildresultresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartnerAppsGetDepotBuildResultResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartnerappsgetdepotbuildresultresponse_unpack(v)? +return i, unpacked +} +pub struct CPartnerAppsFindDRmuploadsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id int +has_app_id bool +} +pub fn (o &CPartnerAppsFindDRmuploadsRequest) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_int32_field(o.app_id, 1) +} + +return res +} + +pub fn cpartnerappsfinddrmuploadsrequest_unpack(buf []byte) ?CPartnerAppsFindDRmuploadsRequest { +mut res := CPartnerAppsFindDRmuploadsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartnerappsfinddrmuploadsrequest() CPartnerAppsFindDRmuploadsRequest { +return CPartnerAppsFindDRmuploadsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartnerappsfinddrmuploadsrequest(o CPartnerAppsFindDRmuploadsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartnerappsfinddrmuploadsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartnerAppsFindDRmuploadsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartnerappsfinddrmuploadsrequest_unpack(v)? +return i, unpacked +} +pub struct CPartnerAppsExistingDRmupload { +mut: +unknown_fields []vproto.UnknownField +pub mut: +file_id string +has_file_id bool +app_id u32 +has_app_id bool +actor_id int +has_actor_id bool +supplied_name string +has_supplied_name bool +flags u32 +has_flags bool +mod_type string +has_mod_type bool +timestamp u32 +has_timestamp bool +orig_file_id string +has_orig_file_id bool +} +pub fn (o &CPartnerAppsExistingDRmupload) pack() []byte { +mut res := []byte{} +if o.has_file_id { +res << vproto.pack_string_field(o.file_id, 1) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 2) +} + +if o.has_actor_id { +res << vproto.pack_int32_field(o.actor_id, 3) +} + +if o.has_supplied_name { +res << vproto.pack_string_field(o.supplied_name, 5) +} + +if o.has_flags { +res << vproto.pack_uint32_field(o.flags, 6) +} + +if o.has_mod_type { +res << vproto.pack_string_field(o.mod_type, 7) +} + +if o.has_timestamp { +res << vproto.pack_32bit_field(o.timestamp, 8) +} + +if o.has_orig_file_id { +res << vproto.pack_string_field(o.orig_file_id, 9) +} + +return res +} + +pub fn cpartnerappsexistingdrmupload_unpack(buf []byte) ?CPartnerAppsExistingDRmupload { +mut res := CPartnerAppsExistingDRmupload{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_file_id = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.file_id = v +i = ii +} + +2 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +3 { +res.has_actor_id = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.actor_id = v +i = ii +} + +5 { +res.has_supplied_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.supplied_name = v +i = ii +} + +6 { +res.has_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.flags = v +i = ii +} + +7 { +res.has_mod_type = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.mod_type = v +i = ii +} + +8 { +res.has_timestamp = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp = v +i = ii +} + +9 { +res.has_orig_file_id = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.orig_file_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartnerappsexistingdrmupload() CPartnerAppsExistingDRmupload { +return CPartnerAppsExistingDRmupload{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartnerappsexistingdrmupload(o CPartnerAppsExistingDRmupload, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartnerappsexistingdrmupload(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartnerAppsExistingDRmupload) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartnerappsexistingdrmupload_unpack(v)? +return i, unpacked +} +pub struct CPartnerAppsFindDRmuploadsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +uploads []CPartnerAppsExistingDRmupload +} +pub fn (o &CPartnerAppsFindDRmuploadsResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.uploads { +res << zzz_vproto_internal_pack_cpartnerappsexistingdrmupload(x, 1) +} + +return res +} + +pub fn cpartnerappsfinddrmuploadsresponse_unpack(buf []byte) ?CPartnerAppsFindDRmuploadsResponse { +mut res := CPartnerAppsFindDRmuploadsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cpartnerappsexistingdrmupload(cur_buf, tag_wiretype.wire_type)? +res.uploads << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartnerappsfinddrmuploadsresponse() CPartnerAppsFindDRmuploadsResponse { +return CPartnerAppsFindDRmuploadsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartnerappsfinddrmuploadsresponse(o CPartnerAppsFindDRmuploadsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartnerappsfinddrmuploadsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartnerAppsFindDRmuploadsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartnerappsfinddrmuploadsresponse_unpack(v)? +return i, unpacked +} +pub struct CPartnerAppsDownloadRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +file_id string +has_file_id bool +app_id int +has_app_id bool +} +pub fn (o &CPartnerAppsDownloadRequest) pack() []byte { +mut res := []byte{} +if o.has_file_id { +res << vproto.pack_string_field(o.file_id, 1) +} + +if o.has_app_id { +res << vproto.pack_int32_field(o.app_id, 2) +} + +return res +} + +pub fn cpartnerappsdownloadrequest_unpack(buf []byte) ?CPartnerAppsDownloadRequest { +mut res := CPartnerAppsDownloadRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_file_id = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.file_id = v +i = ii +} + +2 { +res.has_app_id = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartnerappsdownloadrequest() CPartnerAppsDownloadRequest { +return CPartnerAppsDownloadRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartnerappsdownloadrequest(o CPartnerAppsDownloadRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartnerappsdownloadrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartnerAppsDownloadRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartnerappsdownloadrequest_unpack(v)? +return i, unpacked +} +pub struct CPartnerAppsDownloadResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +download_url string +has_download_url bool +app_id int +has_app_id bool +} +pub fn (o &CPartnerAppsDownloadResponse) pack() []byte { +mut res := []byte{} +if o.has_download_url { +res << vproto.pack_string_field(o.download_url, 1) +} + +if o.has_app_id { +res << vproto.pack_int32_field(o.app_id, 2) +} + +return res +} + +pub fn cpartnerappsdownloadresponse_unpack(buf []byte) ?CPartnerAppsDownloadResponse { +mut res := CPartnerAppsDownloadResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_download_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.download_url = v +i = ii +} + +2 { +res.has_app_id = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpartnerappsdownloadresponse() CPartnerAppsDownloadResponse { +return CPartnerAppsDownloadResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpartnerappsdownloadresponse(o CPartnerAppsDownloadResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpartnerappsdownloadresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPartnerAppsDownloadResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpartnerappsdownloadresponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_player.steamclient_pb.v b/proto/steammessages_player.steamclient_pb.v new file mode 100644 index 0000000..f4699fe --- /dev/null +++ b/proto/steammessages_player.steamclient_pb.v @@ -0,0 +1,6728 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +[_allow_multiple_values] +enum ENotificationSetting { +k_enotificationsettingnotifyusedefault = 0 +k_enotificationsettingalways = 1 +k_enotificationsettingnever = 2 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_enotificationsetting(e ENotificationSetting, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_enotificationsetting(buf []byte, tag_wiretype vproto.WireType) ?(int, ENotificationSetting) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, ENotificationSetting(v) +} +pub struct CPlayerGetMutualFriendsForIncomingInvitesRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPlayerGetMutualFriendsForIncomingInvitesRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn cplayergetmutualfriendsforincominginvitesrequest_unpack(buf []byte) ?CPlayerGetMutualFriendsForIncomingInvitesRequest { +res := CPlayerGetMutualFriendsForIncomingInvitesRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetmutualfriendsforincominginvitesrequest() CPlayerGetMutualFriendsForIncomingInvitesRequest { +return CPlayerGetMutualFriendsForIncomingInvitesRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetmutualfriendsforincominginvitesrequest(o CPlayerGetMutualFriendsForIncomingInvitesRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetmutualfriendsforincominginvitesrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetMutualFriendsForIncomingInvitesRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetmutualfriendsforincominginvitesrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerIncomingInviteMutualFriendList { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +mutual_friend_account_ids []u32 +} +pub fn (o &CPlayerIncomingInviteMutualFriendList) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +// [packed=false] +for _, x in o.mutual_friend_account_ids { +res << vproto.pack_uint32_field(x, 2) +} + +return res +} + +pub fn cplayerincominginvitemutualfriendlist_unpack(buf []byte) ?CPlayerIncomingInviteMutualFriendList { +mut res := CPlayerIncomingInviteMutualFriendList{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.mutual_friend_account_ids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayerincominginvitemutualfriendlist() CPlayerIncomingInviteMutualFriendList { +return CPlayerIncomingInviteMutualFriendList{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayerincominginvitemutualfriendlist(o CPlayerIncomingInviteMutualFriendList, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayerincominginvitemutualfriendlist(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerIncomingInviteMutualFriendList) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayerincominginvitemutualfriendlist_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetMutualFriendsForIncomingInvitesResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +incoming_invite_mutual_friends_lists []CPlayerIncomingInviteMutualFriendList +} +pub fn (o &CPlayerGetMutualFriendsForIncomingInvitesResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.incoming_invite_mutual_friends_lists { +res << zzz_vproto_internal_pack_cplayerincominginvitemutualfriendlist(x, 1) +} + +return res +} + +pub fn cplayergetmutualfriendsforincominginvitesresponse_unpack(buf []byte) ?CPlayerGetMutualFriendsForIncomingInvitesResponse { +mut res := CPlayerGetMutualFriendsForIncomingInvitesResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cplayerincominginvitemutualfriendlist(cur_buf, tag_wiretype.wire_type)? +res.incoming_invite_mutual_friends_lists << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetmutualfriendsforincominginvitesresponse() CPlayerGetMutualFriendsForIncomingInvitesResponse { +return CPlayerGetMutualFriendsForIncomingInvitesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetmutualfriendsforincominginvitesresponse(o CPlayerGetMutualFriendsForIncomingInvitesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetmutualfriendsforincominginvitesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetMutualFriendsForIncomingInvitesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetmutualfriendsforincominginvitesresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetOwnedGamesRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +include_appinfo bool +has_include_appinfo bool +include_played_free_games bool +has_include_played_free_games bool +appids_filter []u32 +include_free_sub bool +has_include_free_sub bool +} +pub fn (o &CPlayerGetOwnedGamesRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_uint64_field(o.steamid, 1) +} + +if o.has_include_appinfo { +res << vproto.pack_bool_field(o.include_appinfo, 2) +} + +if o.has_include_played_free_games { +res << vproto.pack_bool_field(o.include_played_free_games, 3) +} + +// [packed=false] +for _, x in o.appids_filter { +res << vproto.pack_uint32_field(x, 4) +} + +if o.has_include_free_sub { +res << vproto.pack_bool_field(o.include_free_sub, 5) +} + +return res +} + +pub fn cplayergetownedgamesrequest_unpack(buf []byte) ?CPlayerGetOwnedGamesRequest { +mut res := CPlayerGetOwnedGamesRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_include_appinfo = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.include_appinfo = v +i = ii +} + +3 { +res.has_include_played_free_games = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.include_played_free_games = v +i = ii +} + +4 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appids_filter << v +i = ii +} + +5 { +res.has_include_free_sub = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.include_free_sub = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetownedgamesrequest() CPlayerGetOwnedGamesRequest { +return CPlayerGetOwnedGamesRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetownedgamesrequest(o CPlayerGetOwnedGamesRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetownedgamesrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetOwnedGamesRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetownedgamesrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetOwnedGamesResponseGame { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid int +has_appid bool +name string +has_name bool +playtime_2weeks int +has_playtime_2weeks bool +playtime_forever int +has_playtime_forever bool +img_icon_url string +has_img_icon_url bool +img_logo_url string +has_img_logo_url bool +has_community_visible_stats bool +has_has_community_visible_stats bool +playtime_windows_forever int +has_playtime_windows_forever bool +playtime_mac_forever int +has_playtime_mac_forever bool +playtime_linux_forever int +has_playtime_linux_forever bool +} +pub fn (o &CPlayerGetOwnedGamesResponseGame) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_int32_field(o.appid, 1) +} + +if o.has_name { +res << vproto.pack_string_field(o.name, 2) +} + +if o.has_playtime_2weeks { +res << vproto.pack_int32_field(o.playtime_2weeks, 3) +} + +if o.has_playtime_forever { +res << vproto.pack_int32_field(o.playtime_forever, 4) +} + +if o.has_img_icon_url { +res << vproto.pack_string_field(o.img_icon_url, 5) +} + +if o.has_img_logo_url { +res << vproto.pack_string_field(o.img_logo_url, 6) +} + +if o.has_has_community_visible_stats { +res << vproto.pack_bool_field(o.has_community_visible_stats, 7) +} + +if o.has_playtime_windows_forever { +res << vproto.pack_int32_field(o.playtime_windows_forever, 8) +} + +if o.has_playtime_mac_forever { +res << vproto.pack_int32_field(o.playtime_mac_forever, 9) +} + +if o.has_playtime_linux_forever { +res << vproto.pack_int32_field(o.playtime_linux_forever, 10) +} + +return res +} + +pub fn cplayergetownedgamesresponsegame_unpack(buf []byte) ?CPlayerGetOwnedGamesResponseGame { +mut res := CPlayerGetOwnedGamesResponseGame{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +3 { +res.has_playtime_2weeks = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.playtime_2weeks = v +i = ii +} + +4 { +res.has_playtime_forever = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.playtime_forever = v +i = ii +} + +5 { +res.has_img_icon_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.img_icon_url = v +i = ii +} + +6 { +res.has_img_logo_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.img_logo_url = v +i = ii +} + +7 { +res.has_has_community_visible_stats = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.has_community_visible_stats = v +i = ii +} + +8 { +res.has_playtime_windows_forever = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.playtime_windows_forever = v +i = ii +} + +9 { +res.has_playtime_mac_forever = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.playtime_mac_forever = v +i = ii +} + +10 { +res.has_playtime_linux_forever = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.playtime_linux_forever = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetownedgamesresponsegame() CPlayerGetOwnedGamesResponseGame { +return CPlayerGetOwnedGamesResponseGame{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetownedgamesresponsegame(o CPlayerGetOwnedGamesResponseGame, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetownedgamesresponsegame(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetOwnedGamesResponseGame) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetownedgamesresponsegame_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetOwnedGamesResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +game_count u32 +has_game_count bool +games []CPlayerGetOwnedGamesResponseGame +} +pub fn (o &CPlayerGetOwnedGamesResponse) pack() []byte { +mut res := []byte{} +if o.has_game_count { +res << vproto.pack_uint32_field(o.game_count, 1) +} + +// [packed=false] +for _, x in o.games { +res << zzz_vproto_internal_pack_cplayergetownedgamesresponsegame(x, 2) +} + +return res +} + +pub fn cplayergetownedgamesresponse_unpack(buf []byte) ?CPlayerGetOwnedGamesResponse { +mut res := CPlayerGetOwnedGamesResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_game_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.game_count = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cplayergetownedgamesresponsegame(cur_buf, tag_wiretype.wire_type)? +res.games << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetownedgamesresponse() CPlayerGetOwnedGamesResponse { +return CPlayerGetOwnedGamesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetownedgamesresponse(o CPlayerGetOwnedGamesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetownedgamesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetOwnedGamesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetownedgamesresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetPlayNextRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +max_age_seconds u32 +has_max_age_seconds bool +ignore_appids []u32 +} +pub fn (o &CPlayerGetPlayNextRequest) pack() []byte { +mut res := []byte{} +if o.has_max_age_seconds { +res << vproto.pack_uint32_field(o.max_age_seconds, 1) +} + +// [packed=false] +for _, x in o.ignore_appids { +res << vproto.pack_uint32_field(x, 2) +} + +return res +} + +pub fn cplayergetplaynextrequest_unpack(buf []byte) ?CPlayerGetPlayNextRequest { +mut res := CPlayerGetPlayNextRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_max_age_seconds = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.max_age_seconds = v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ignore_appids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetplaynextrequest() CPlayerGetPlayNextRequest { +return CPlayerGetPlayNextRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetplaynextrequest(o CPlayerGetPlayNextRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetplaynextrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetPlayNextRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetplaynextrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetPlayNextResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +last_update_time u32 +has_last_update_time bool +appids []u32 +} +pub fn (o &CPlayerGetPlayNextResponse) pack() []byte { +mut res := []byte{} +if o.has_last_update_time { +res << vproto.pack_uint32_field(o.last_update_time, 1) +} + +// [packed=false] +for _, x in o.appids { +res << vproto.pack_uint32_field(x, 2) +} + +return res +} + +pub fn cplayergetplaynextresponse_unpack(buf []byte) ?CPlayerGetPlayNextResponse { +mut res := CPlayerGetPlayNextResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_last_update_time = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_update_time = v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetplaynextresponse() CPlayerGetPlayNextResponse { +return CPlayerGetPlayNextResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetplaynextresponse(o CPlayerGetPlayNextResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetplaynextresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetPlayNextResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetplaynextresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetFriendsGameplayInfoRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +} +pub fn (o &CPlayerGetFriendsGameplayInfoRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +return res +} + +pub fn cplayergetfriendsgameplayinforequest_unpack(buf []byte) ?CPlayerGetFriendsGameplayInfoRequest { +mut res := CPlayerGetFriendsGameplayInfoRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetfriendsgameplayinforequest() CPlayerGetFriendsGameplayInfoRequest { +return CPlayerGetFriendsGameplayInfoRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetfriendsgameplayinforequest(o CPlayerGetFriendsGameplayInfoRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetfriendsgameplayinforequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetFriendsGameplayInfoRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetfriendsgameplayinforequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetFriendsGameplayInfoResponseFriendsGameplayInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +minutes_played u32 +has_minutes_played bool +minutes_played_forever u32 +has_minutes_played_forever bool +} +pub fn (o &CPlayerGetFriendsGameplayInfoResponseFriendsGameplayInfo) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_minutes_played { +res << vproto.pack_uint32_field(o.minutes_played, 2) +} + +if o.has_minutes_played_forever { +res << vproto.pack_uint32_field(o.minutes_played_forever, 3) +} + +return res +} + +pub fn cplayergetfriendsgameplayinforesponsefriendsgameplayinfo_unpack(buf []byte) ?CPlayerGetFriendsGameplayInfoResponseFriendsGameplayInfo { +mut res := CPlayerGetFriendsGameplayInfoResponseFriendsGameplayInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_minutes_played = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.minutes_played = v +i = ii +} + +3 { +res.has_minutes_played_forever = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.minutes_played_forever = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetfriendsgameplayinforesponsefriendsgameplayinfo() CPlayerGetFriendsGameplayInfoResponseFriendsGameplayInfo { +return CPlayerGetFriendsGameplayInfoResponseFriendsGameplayInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetfriendsgameplayinforesponsefriendsgameplayinfo(o CPlayerGetFriendsGameplayInfoResponseFriendsGameplayInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetfriendsgameplayinforesponsefriendsgameplayinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetFriendsGameplayInfoResponseFriendsGameplayInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetfriendsgameplayinforesponsefriendsgameplayinfo_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetFriendsGameplayInfoResponseOwnGameplayInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +minutes_played u32 +has_minutes_played bool +minutes_played_forever u32 +has_minutes_played_forever bool +in_wishlist bool +has_in_wishlist bool +owned bool +has_owned bool +} +pub fn (o &CPlayerGetFriendsGameplayInfoResponseOwnGameplayInfo) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_minutes_played { +res << vproto.pack_uint32_field(o.minutes_played, 2) +} + +if o.has_minutes_played_forever { +res << vproto.pack_uint32_field(o.minutes_played_forever, 3) +} + +if o.has_in_wishlist { +res << vproto.pack_bool_field(o.in_wishlist, 4) +} + +if o.has_owned { +res << vproto.pack_bool_field(o.owned, 5) +} + +return res +} + +pub fn cplayergetfriendsgameplayinforesponseowngameplayinfo_unpack(buf []byte) ?CPlayerGetFriendsGameplayInfoResponseOwnGameplayInfo { +mut res := CPlayerGetFriendsGameplayInfoResponseOwnGameplayInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_minutes_played = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.minutes_played = v +i = ii +} + +3 { +res.has_minutes_played_forever = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.minutes_played_forever = v +i = ii +} + +4 { +res.has_in_wishlist = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.in_wishlist = v +i = ii +} + +5 { +res.has_owned = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.owned = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetfriendsgameplayinforesponseowngameplayinfo() CPlayerGetFriendsGameplayInfoResponseOwnGameplayInfo { +return CPlayerGetFriendsGameplayInfoResponseOwnGameplayInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetfriendsgameplayinforesponseowngameplayinfo(o CPlayerGetFriendsGameplayInfoResponseOwnGameplayInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetfriendsgameplayinforesponseowngameplayinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetFriendsGameplayInfoResponseOwnGameplayInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetfriendsgameplayinforesponseowngameplayinfo_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetFriendsGameplayInfoResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +your_info CPlayerGetFriendsGameplayInfoResponseOwnGameplayInfo +has_your_info bool +in_game []CPlayerGetFriendsGameplayInfoResponseFriendsGameplayInfo +played_recently []CPlayerGetFriendsGameplayInfoResponseFriendsGameplayInfo +played_ever []CPlayerGetFriendsGameplayInfoResponseFriendsGameplayInfo +owns []CPlayerGetFriendsGameplayInfoResponseFriendsGameplayInfo +in_wishlist []CPlayerGetFriendsGameplayInfoResponseFriendsGameplayInfo +} +pub fn (o &CPlayerGetFriendsGameplayInfoResponse) pack() []byte { +mut res := []byte{} +if o.has_your_info { +res << zzz_vproto_internal_pack_cplayergetfriendsgameplayinforesponseowngameplayinfo(o.your_info, 1) +} + +// [packed=false] +for _, x in o.in_game { +res << zzz_vproto_internal_pack_cplayergetfriendsgameplayinforesponsefriendsgameplayinfo(x, 2) +} + +// [packed=false] +for _, x in o.played_recently { +res << zzz_vproto_internal_pack_cplayergetfriendsgameplayinforesponsefriendsgameplayinfo(x, 3) +} + +// [packed=false] +for _, x in o.played_ever { +res << zzz_vproto_internal_pack_cplayergetfriendsgameplayinforesponsefriendsgameplayinfo(x, 4) +} + +// [packed=false] +for _, x in o.owns { +res << zzz_vproto_internal_pack_cplayergetfriendsgameplayinforesponsefriendsgameplayinfo(x, 5) +} + +// [packed=false] +for _, x in o.in_wishlist { +res << zzz_vproto_internal_pack_cplayergetfriendsgameplayinforesponsefriendsgameplayinfo(x, 6) +} + +return res +} + +pub fn cplayergetfriendsgameplayinforesponse_unpack(buf []byte) ?CPlayerGetFriendsGameplayInfoResponse { +mut res := CPlayerGetFriendsGameplayInfoResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_your_info = true +ii, v := zzz_vproto_internal_unpack_cplayergetfriendsgameplayinforesponseowngameplayinfo(cur_buf, tag_wiretype.wire_type)? +res.your_info = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cplayergetfriendsgameplayinforesponsefriendsgameplayinfo(cur_buf, tag_wiretype.wire_type)? +res.in_game << v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cplayergetfriendsgameplayinforesponsefriendsgameplayinfo(cur_buf, tag_wiretype.wire_type)? +res.played_recently << v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cplayergetfriendsgameplayinforesponsefriendsgameplayinfo(cur_buf, tag_wiretype.wire_type)? +res.played_ever << v +i = ii +} + +5 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cplayergetfriendsgameplayinforesponsefriendsgameplayinfo(cur_buf, tag_wiretype.wire_type)? +res.owns << v +i = ii +} + +6 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cplayergetfriendsgameplayinforesponsefriendsgameplayinfo(cur_buf, tag_wiretype.wire_type)? +res.in_wishlist << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetfriendsgameplayinforesponse() CPlayerGetFriendsGameplayInfoResponse { +return CPlayerGetFriendsGameplayInfoResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetfriendsgameplayinforesponse(o CPlayerGetFriendsGameplayInfoResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetfriendsgameplayinforesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetFriendsGameplayInfoResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetfriendsgameplayinforesponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetFriendsAppsActivityRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +news_language string +has_news_language bool +request_flags u32 +has_request_flags bool +} +pub fn (o &CPlayerGetFriendsAppsActivityRequest) pack() []byte { +mut res := []byte{} +if o.has_news_language { +res << vproto.pack_string_field(o.news_language, 1) +} + +if o.has_request_flags { +res << vproto.pack_uint32_field(o.request_flags, 2) +} + +return res +} + +pub fn cplayergetfriendsappsactivityrequest_unpack(buf []byte) ?CPlayerGetFriendsAppsActivityRequest { +mut res := CPlayerGetFriendsAppsActivityRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_news_language = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.news_language = v +i = ii +} + +2 { +res.has_request_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.request_flags = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetfriendsappsactivityrequest() CPlayerGetFriendsAppsActivityRequest { +return CPlayerGetFriendsAppsActivityRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetfriendsappsactivityrequest(o CPlayerGetFriendsAppsActivityRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetfriendsappsactivityrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetFriendsAppsActivityRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetfriendsappsactivityrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetFriendsAppsActivityResponseFriendPlayTime { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +minutes_played_this_week u32 +has_minutes_played_this_week bool +minutes_played_two_weeks u32 +has_minutes_played_two_weeks bool +minutes_played_forever u32 +has_minutes_played_forever bool +event_count u32 +has_event_count bool +} +pub fn (o &CPlayerGetFriendsAppsActivityResponseFriendPlayTime) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_minutes_played_this_week { +res << vproto.pack_uint32_field(o.minutes_played_this_week, 2) +} + +if o.has_minutes_played_two_weeks { +res << vproto.pack_uint32_field(o.minutes_played_two_weeks, 3) +} + +if o.has_minutes_played_forever { +res << vproto.pack_uint32_field(o.minutes_played_forever, 4) +} + +if o.has_event_count { +res << vproto.pack_uint32_field(o.event_count, 5) +} + +return res +} + +pub fn cplayergetfriendsappsactivityresponsefriendplaytime_unpack(buf []byte) ?CPlayerGetFriendsAppsActivityResponseFriendPlayTime { +mut res := CPlayerGetFriendsAppsActivityResponseFriendPlayTime{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_minutes_played_this_week = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.minutes_played_this_week = v +i = ii +} + +3 { +res.has_minutes_played_two_weeks = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.minutes_played_two_weeks = v +i = ii +} + +4 { +res.has_minutes_played_forever = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.minutes_played_forever = v +i = ii +} + +5 { +res.has_event_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.event_count = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetfriendsappsactivityresponsefriendplaytime() CPlayerGetFriendsAppsActivityResponseFriendPlayTime { +return CPlayerGetFriendsAppsActivityResponseFriendPlayTime{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetfriendsappsactivityresponsefriendplaytime(o CPlayerGetFriendsAppsActivityResponseFriendPlayTime, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetfriendsappsactivityresponsefriendplaytime(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetFriendsAppsActivityResponseFriendPlayTime) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetfriendsappsactivityresponsefriendplaytime_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetFriendsAppsActivityResponseAppFriendsInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +friends []CPlayerGetFriendsAppsActivityResponseFriendPlayTime +display_order u32 +has_display_order bool +} +pub fn (o &CPlayerGetFriendsAppsActivityResponseAppFriendsInfo) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +// [packed=false] +for _, x in o.friends { +res << zzz_vproto_internal_pack_cplayergetfriendsappsactivityresponsefriendplaytime(x, 2) +} + +if o.has_display_order { +res << vproto.pack_uint32_field(o.display_order, 3) +} + +return res +} + +pub fn cplayergetfriendsappsactivityresponseappfriendsinfo_unpack(buf []byte) ?CPlayerGetFriendsAppsActivityResponseAppFriendsInfo { +mut res := CPlayerGetFriendsAppsActivityResponseAppFriendsInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cplayergetfriendsappsactivityresponsefriendplaytime(cur_buf, tag_wiretype.wire_type)? +res.friends << v +i = ii +} + +3 { +res.has_display_order = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.display_order = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetfriendsappsactivityresponseappfriendsinfo() CPlayerGetFriendsAppsActivityResponseAppFriendsInfo { +return CPlayerGetFriendsAppsActivityResponseAppFriendsInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetfriendsappsactivityresponseappfriendsinfo(o CPlayerGetFriendsAppsActivityResponseAppFriendsInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetfriendsappsactivityresponseappfriendsinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetFriendsAppsActivityResponseAppFriendsInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetfriendsappsactivityresponseappfriendsinfo_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetFriendsAppsActivityResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +trending []CPlayerGetFriendsAppsActivityResponseAppFriendsInfo +recent_purchases []CPlayerGetFriendsAppsActivityResponseAppFriendsInfo +unowned []CPlayerGetFriendsAppsActivityResponseAppFriendsInfo +popular []CPlayerGetFriendsAppsActivityResponseAppFriendsInfo +dont_forget []CPlayerGetFriendsAppsActivityResponseAppFriendsInfo +being_discussed []CPlayerGetFriendsAppsActivityResponseAppFriendsInfo +new_to_group []CPlayerGetFriendsAppsActivityResponseAppFriendsInfo +returned_to_group []CPlayerGetFriendsAppsActivityResponseAppFriendsInfo +active_friend_count u32 +has_active_friend_count bool +} +pub fn (o &CPlayerGetFriendsAppsActivityResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.trending { +res << zzz_vproto_internal_pack_cplayergetfriendsappsactivityresponseappfriendsinfo(x, 1) +} + +// [packed=false] +for _, x in o.recent_purchases { +res << zzz_vproto_internal_pack_cplayergetfriendsappsactivityresponseappfriendsinfo(x, 2) +} + +// [packed=false] +for _, x in o.unowned { +res << zzz_vproto_internal_pack_cplayergetfriendsappsactivityresponseappfriendsinfo(x, 3) +} + +// [packed=false] +for _, x in o.popular { +res << zzz_vproto_internal_pack_cplayergetfriendsappsactivityresponseappfriendsinfo(x, 4) +} + +// [packed=false] +for _, x in o.dont_forget { +res << zzz_vproto_internal_pack_cplayergetfriendsappsactivityresponseappfriendsinfo(x, 5) +} + +// [packed=false] +for _, x in o.being_discussed { +res << zzz_vproto_internal_pack_cplayergetfriendsappsactivityresponseappfriendsinfo(x, 6) +} + +// [packed=false] +for _, x in o.new_to_group { +res << zzz_vproto_internal_pack_cplayergetfriendsappsactivityresponseappfriendsinfo(x, 7) +} + +// [packed=false] +for _, x in o.returned_to_group { +res << zzz_vproto_internal_pack_cplayergetfriendsappsactivityresponseappfriendsinfo(x, 8) +} + +if o.has_active_friend_count { +res << vproto.pack_uint32_field(o.active_friend_count, 9) +} + +return res +} + +pub fn cplayergetfriendsappsactivityresponse_unpack(buf []byte) ?CPlayerGetFriendsAppsActivityResponse { +mut res := CPlayerGetFriendsAppsActivityResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cplayergetfriendsappsactivityresponseappfriendsinfo(cur_buf, tag_wiretype.wire_type)? +res.trending << v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cplayergetfriendsappsactivityresponseappfriendsinfo(cur_buf, tag_wiretype.wire_type)? +res.recent_purchases << v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cplayergetfriendsappsactivityresponseappfriendsinfo(cur_buf, tag_wiretype.wire_type)? +res.unowned << v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cplayergetfriendsappsactivityresponseappfriendsinfo(cur_buf, tag_wiretype.wire_type)? +res.popular << v +i = ii +} + +5 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cplayergetfriendsappsactivityresponseappfriendsinfo(cur_buf, tag_wiretype.wire_type)? +res.dont_forget << v +i = ii +} + +6 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cplayergetfriendsappsactivityresponseappfriendsinfo(cur_buf, tag_wiretype.wire_type)? +res.being_discussed << v +i = ii +} + +7 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cplayergetfriendsappsactivityresponseappfriendsinfo(cur_buf, tag_wiretype.wire_type)? +res.new_to_group << v +i = ii +} + +8 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cplayergetfriendsappsactivityresponseappfriendsinfo(cur_buf, tag_wiretype.wire_type)? +res.returned_to_group << v +i = ii +} + +9 { +res.has_active_friend_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.active_friend_count = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetfriendsappsactivityresponse() CPlayerGetFriendsAppsActivityResponse { +return CPlayerGetFriendsAppsActivityResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetfriendsappsactivityresponse(o CPlayerGetFriendsAppsActivityResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetfriendsappsactivityresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetFriendsAppsActivityResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetfriendsappsactivityresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetGameBadgeLevelsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +} +pub fn (o &CPlayerGetGameBadgeLevelsRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +return res +} + +pub fn cplayergetgamebadgelevelsrequest_unpack(buf []byte) ?CPlayerGetGameBadgeLevelsRequest { +mut res := CPlayerGetGameBadgeLevelsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetgamebadgelevelsrequest() CPlayerGetGameBadgeLevelsRequest { +return CPlayerGetGameBadgeLevelsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetgamebadgelevelsrequest(o CPlayerGetGameBadgeLevelsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetgamebadgelevelsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetGameBadgeLevelsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetgamebadgelevelsrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetGameBadgeLevelsResponseBadge { +mut: +unknown_fields []vproto.UnknownField +pub mut: +level int +has_level bool +series int +has_series bool +border_color u32 +has_border_color bool +} +pub fn (o &CPlayerGetGameBadgeLevelsResponseBadge) pack() []byte { +mut res := []byte{} +if o.has_level { +res << vproto.pack_int32_field(o.level, 1) +} + +if o.has_series { +res << vproto.pack_int32_field(o.series, 2) +} + +if o.has_border_color { +res << vproto.pack_uint32_field(o.border_color, 3) +} + +return res +} + +pub fn cplayergetgamebadgelevelsresponsebadge_unpack(buf []byte) ?CPlayerGetGameBadgeLevelsResponseBadge { +mut res := CPlayerGetGameBadgeLevelsResponseBadge{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_level = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.level = v +i = ii +} + +2 { +res.has_series = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.series = v +i = ii +} + +3 { +res.has_border_color = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.border_color = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetgamebadgelevelsresponsebadge() CPlayerGetGameBadgeLevelsResponseBadge { +return CPlayerGetGameBadgeLevelsResponseBadge{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetgamebadgelevelsresponsebadge(o CPlayerGetGameBadgeLevelsResponseBadge, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetgamebadgelevelsresponsebadge(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetGameBadgeLevelsResponseBadge) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetgamebadgelevelsresponsebadge_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetGameBadgeLevelsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +player_level u32 +has_player_level bool +badges []CPlayerGetGameBadgeLevelsResponseBadge +} +pub fn (o &CPlayerGetGameBadgeLevelsResponse) pack() []byte { +mut res := []byte{} +if o.has_player_level { +res << vproto.pack_uint32_field(o.player_level, 1) +} + +// [packed=false] +for _, x in o.badges { +res << zzz_vproto_internal_pack_cplayergetgamebadgelevelsresponsebadge(x, 2) +} + +return res +} + +pub fn cplayergetgamebadgelevelsresponse_unpack(buf []byte) ?CPlayerGetGameBadgeLevelsResponse { +mut res := CPlayerGetGameBadgeLevelsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_player_level = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.player_level = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cplayergetgamebadgelevelsresponsebadge(cur_buf, tag_wiretype.wire_type)? +res.badges << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetgamebadgelevelsresponse() CPlayerGetGameBadgeLevelsResponse { +return CPlayerGetGameBadgeLevelsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetgamebadgelevelsresponse(o CPlayerGetGameBadgeLevelsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetgamebadgelevelsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetGameBadgeLevelsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetgamebadgelevelsresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetProfileBackgroundRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +language string +has_language bool +} +pub fn (o &CPlayerGetProfileBackgroundRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_language { +res << vproto.pack_string_field(o.language, 2) +} + +return res +} + +pub fn cplayergetprofilebackgroundrequest_unpack(buf []byte) ?CPlayerGetProfileBackgroundRequest { +mut res := CPlayerGetProfileBackgroundRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_language = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetprofilebackgroundrequest() CPlayerGetProfileBackgroundRequest { +return CPlayerGetProfileBackgroundRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetprofilebackgroundrequest(o CPlayerGetProfileBackgroundRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetprofilebackgroundrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetProfileBackgroundRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetprofilebackgroundrequest_unpack(v)? +return i, unpacked +} +pub struct ProfileItem { +mut: +unknown_fields []vproto.UnknownField +pub mut: +communityitemid u64 +has_communityitemid bool +image_small string +has_image_small bool +image_large string +has_image_large bool +name string +has_name bool +item_title string +has_item_title bool +item_description string +has_item_description bool +appid u32 +has_appid bool +item_type u32 +has_item_type bool +item_class u32 +has_item_class bool +movie_webm string +has_movie_webm bool +movie_mp4 string +has_movie_mp4 bool +equipped_flags u32 +has_equipped_flags bool +} +pub fn (o &ProfileItem) pack() []byte { +mut res := []byte{} +if o.has_communityitemid { +res << vproto.pack_uint64_field(o.communityitemid, 1) +} + +if o.has_image_small { +res << vproto.pack_string_field(o.image_small, 2) +} + +if o.has_image_large { +res << vproto.pack_string_field(o.image_large, 3) +} + +if o.has_name { +res << vproto.pack_string_field(o.name, 4) +} + +if o.has_item_title { +res << vproto.pack_string_field(o.item_title, 5) +} + +if o.has_item_description { +res << vproto.pack_string_field(o.item_description, 6) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 7) +} + +if o.has_item_type { +res << vproto.pack_uint32_field(o.item_type, 8) +} + +if o.has_item_class { +res << vproto.pack_uint32_field(o.item_class, 9) +} + +if o.has_movie_webm { +res << vproto.pack_string_field(o.movie_webm, 10) +} + +if o.has_movie_mp4 { +res << vproto.pack_string_field(o.movie_mp4, 11) +} + +if o.has_equipped_flags { +res << vproto.pack_uint32_field(o.equipped_flags, 12) +} + +return res +} + +pub fn profileitem_unpack(buf []byte) ?ProfileItem { +mut res := ProfileItem{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_communityitemid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.communityitemid = v +i = ii +} + +2 { +res.has_image_small = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.image_small = v +i = ii +} + +3 { +res.has_image_large = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.image_large = v +i = ii +} + +4 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +5 { +res.has_item_title = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.item_title = v +i = ii +} + +6 { +res.has_item_description = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.item_description = v +i = ii +} + +7 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +8 { +res.has_item_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.item_type = v +i = ii +} + +9 { +res.has_item_class = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.item_class = v +i = ii +} + +10 { +res.has_movie_webm = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.movie_webm = v +i = ii +} + +11 { +res.has_movie_mp4 = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.movie_mp4 = v +i = ii +} + +12 { +res.has_equipped_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.equipped_flags = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_profileitem() ProfileItem { +return ProfileItem{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_profileitem(o ProfileItem, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_profileitem(buf []byte, tag_wiretype vproto.WireType) ?(int, ProfileItem) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := profileitem_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetProfileBackgroundResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +profile_background ProfileItem +has_profile_background bool +} +pub fn (o &CPlayerGetProfileBackgroundResponse) pack() []byte { +mut res := []byte{} +if o.has_profile_background { +res << zzz_vproto_internal_pack_profileitem(o.profile_background, 1) +} + +return res +} + +pub fn cplayergetprofilebackgroundresponse_unpack(buf []byte) ?CPlayerGetProfileBackgroundResponse { +mut res := CPlayerGetProfileBackgroundResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_profile_background = true +ii, v := zzz_vproto_internal_unpack_profileitem(cur_buf, tag_wiretype.wire_type)? +res.profile_background = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetprofilebackgroundresponse() CPlayerGetProfileBackgroundResponse { +return CPlayerGetProfileBackgroundResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetprofilebackgroundresponse(o CPlayerGetProfileBackgroundResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetprofilebackgroundresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetProfileBackgroundResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetprofilebackgroundresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerSetProfileBackgroundRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +communityitemid u64 +has_communityitemid bool +} +pub fn (o &CPlayerSetProfileBackgroundRequest) pack() []byte { +mut res := []byte{} +if o.has_communityitemid { +res << vproto.pack_uint64_field(o.communityitemid, 1) +} + +return res +} + +pub fn cplayersetprofilebackgroundrequest_unpack(buf []byte) ?CPlayerSetProfileBackgroundRequest { +mut res := CPlayerSetProfileBackgroundRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_communityitemid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.communityitemid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayersetprofilebackgroundrequest() CPlayerSetProfileBackgroundRequest { +return CPlayerSetProfileBackgroundRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayersetprofilebackgroundrequest(o CPlayerSetProfileBackgroundRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayersetprofilebackgroundrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerSetProfileBackgroundRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayersetprofilebackgroundrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerSetProfileBackgroundResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPlayerSetProfileBackgroundResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cplayersetprofilebackgroundresponse_unpack(buf []byte) ?CPlayerSetProfileBackgroundResponse { +res := CPlayerSetProfileBackgroundResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayersetprofilebackgroundresponse() CPlayerSetProfileBackgroundResponse { +return CPlayerSetProfileBackgroundResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayersetprofilebackgroundresponse(o CPlayerSetProfileBackgroundResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayersetprofilebackgroundresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerSetProfileBackgroundResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayersetprofilebackgroundresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetMiniProfileBackgroundRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +language string +has_language bool +} +pub fn (o &CPlayerGetMiniProfileBackgroundRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_language { +res << vproto.pack_string_field(o.language, 2) +} + +return res +} + +pub fn cplayergetminiprofilebackgroundrequest_unpack(buf []byte) ?CPlayerGetMiniProfileBackgroundRequest { +mut res := CPlayerGetMiniProfileBackgroundRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_language = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetminiprofilebackgroundrequest() CPlayerGetMiniProfileBackgroundRequest { +return CPlayerGetMiniProfileBackgroundRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetminiprofilebackgroundrequest(o CPlayerGetMiniProfileBackgroundRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetminiprofilebackgroundrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetMiniProfileBackgroundRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetminiprofilebackgroundrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetMiniProfileBackgroundResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +profile_background ProfileItem +has_profile_background bool +} +pub fn (o &CPlayerGetMiniProfileBackgroundResponse) pack() []byte { +mut res := []byte{} +if o.has_profile_background { +res << zzz_vproto_internal_pack_profileitem(o.profile_background, 1) +} + +return res +} + +pub fn cplayergetminiprofilebackgroundresponse_unpack(buf []byte) ?CPlayerGetMiniProfileBackgroundResponse { +mut res := CPlayerGetMiniProfileBackgroundResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_profile_background = true +ii, v := zzz_vproto_internal_unpack_profileitem(cur_buf, tag_wiretype.wire_type)? +res.profile_background = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetminiprofilebackgroundresponse() CPlayerGetMiniProfileBackgroundResponse { +return CPlayerGetMiniProfileBackgroundResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetminiprofilebackgroundresponse(o CPlayerGetMiniProfileBackgroundResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetminiprofilebackgroundresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetMiniProfileBackgroundResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetminiprofilebackgroundresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerSetMiniProfileBackgroundRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +communityitemid u64 +has_communityitemid bool +} +pub fn (o &CPlayerSetMiniProfileBackgroundRequest) pack() []byte { +mut res := []byte{} +if o.has_communityitemid { +res << vproto.pack_uint64_field(o.communityitemid, 1) +} + +return res +} + +pub fn cplayersetminiprofilebackgroundrequest_unpack(buf []byte) ?CPlayerSetMiniProfileBackgroundRequest { +mut res := CPlayerSetMiniProfileBackgroundRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_communityitemid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.communityitemid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayersetminiprofilebackgroundrequest() CPlayerSetMiniProfileBackgroundRequest { +return CPlayerSetMiniProfileBackgroundRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayersetminiprofilebackgroundrequest(o CPlayerSetMiniProfileBackgroundRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayersetminiprofilebackgroundrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerSetMiniProfileBackgroundRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayersetminiprofilebackgroundrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerSetMiniProfileBackgroundResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPlayerSetMiniProfileBackgroundResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cplayersetminiprofilebackgroundresponse_unpack(buf []byte) ?CPlayerSetMiniProfileBackgroundResponse { +res := CPlayerSetMiniProfileBackgroundResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayersetminiprofilebackgroundresponse() CPlayerSetMiniProfileBackgroundResponse { +return CPlayerSetMiniProfileBackgroundResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayersetminiprofilebackgroundresponse(o CPlayerSetMiniProfileBackgroundResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayersetminiprofilebackgroundresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerSetMiniProfileBackgroundResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayersetminiprofilebackgroundresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetAvatarFrameRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +language string +has_language bool +} +pub fn (o &CPlayerGetAvatarFrameRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_language { +res << vproto.pack_string_field(o.language, 2) +} + +return res +} + +pub fn cplayergetavatarframerequest_unpack(buf []byte) ?CPlayerGetAvatarFrameRequest { +mut res := CPlayerGetAvatarFrameRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_language = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetavatarframerequest() CPlayerGetAvatarFrameRequest { +return CPlayerGetAvatarFrameRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetavatarframerequest(o CPlayerGetAvatarFrameRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetavatarframerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetAvatarFrameRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetavatarframerequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetAvatarFrameResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +avatar_frame ProfileItem +has_avatar_frame bool +} +pub fn (o &CPlayerGetAvatarFrameResponse) pack() []byte { +mut res := []byte{} +if o.has_avatar_frame { +res << zzz_vproto_internal_pack_profileitem(o.avatar_frame, 1) +} + +return res +} + +pub fn cplayergetavatarframeresponse_unpack(buf []byte) ?CPlayerGetAvatarFrameResponse { +mut res := CPlayerGetAvatarFrameResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_avatar_frame = true +ii, v := zzz_vproto_internal_unpack_profileitem(cur_buf, tag_wiretype.wire_type)? +res.avatar_frame = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetavatarframeresponse() CPlayerGetAvatarFrameResponse { +return CPlayerGetAvatarFrameResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetavatarframeresponse(o CPlayerGetAvatarFrameResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetavatarframeresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetAvatarFrameResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetavatarframeresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerSetAvatarFrameRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +communityitemid u64 +has_communityitemid bool +} +pub fn (o &CPlayerSetAvatarFrameRequest) pack() []byte { +mut res := []byte{} +if o.has_communityitemid { +res << vproto.pack_uint64_field(o.communityitemid, 1) +} + +return res +} + +pub fn cplayersetavatarframerequest_unpack(buf []byte) ?CPlayerSetAvatarFrameRequest { +mut res := CPlayerSetAvatarFrameRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_communityitemid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.communityitemid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayersetavatarframerequest() CPlayerSetAvatarFrameRequest { +return CPlayerSetAvatarFrameRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayersetavatarframerequest(o CPlayerSetAvatarFrameRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayersetavatarframerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerSetAvatarFrameRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayersetavatarframerequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerSetAvatarFrameResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPlayerSetAvatarFrameResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cplayersetavatarframeresponse_unpack(buf []byte) ?CPlayerSetAvatarFrameResponse { +res := CPlayerSetAvatarFrameResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayersetavatarframeresponse() CPlayerSetAvatarFrameResponse { +return CPlayerSetAvatarFrameResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayersetavatarframeresponse(o CPlayerSetAvatarFrameResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayersetavatarframeresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerSetAvatarFrameResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayersetavatarframeresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetAnimatedAvatarRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +language string +has_language bool +} +pub fn (o &CPlayerGetAnimatedAvatarRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_language { +res << vproto.pack_string_field(o.language, 2) +} + +return res +} + +pub fn cplayergetanimatedavatarrequest_unpack(buf []byte) ?CPlayerGetAnimatedAvatarRequest { +mut res := CPlayerGetAnimatedAvatarRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_language = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetanimatedavatarrequest() CPlayerGetAnimatedAvatarRequest { +return CPlayerGetAnimatedAvatarRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetanimatedavatarrequest(o CPlayerGetAnimatedAvatarRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetanimatedavatarrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetAnimatedAvatarRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetanimatedavatarrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetAnimatedAvatarResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +avatar ProfileItem +has_avatar bool +} +pub fn (o &CPlayerGetAnimatedAvatarResponse) pack() []byte { +mut res := []byte{} +if o.has_avatar { +res << zzz_vproto_internal_pack_profileitem(o.avatar, 1) +} + +return res +} + +pub fn cplayergetanimatedavatarresponse_unpack(buf []byte) ?CPlayerGetAnimatedAvatarResponse { +mut res := CPlayerGetAnimatedAvatarResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_avatar = true +ii, v := zzz_vproto_internal_unpack_profileitem(cur_buf, tag_wiretype.wire_type)? +res.avatar = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetanimatedavatarresponse() CPlayerGetAnimatedAvatarResponse { +return CPlayerGetAnimatedAvatarResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetanimatedavatarresponse(o CPlayerGetAnimatedAvatarResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetanimatedavatarresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetAnimatedAvatarResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetanimatedavatarresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerSetAnimatedAvatarRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +communityitemid u64 +has_communityitemid bool +} +pub fn (o &CPlayerSetAnimatedAvatarRequest) pack() []byte { +mut res := []byte{} +if o.has_communityitemid { +res << vproto.pack_uint64_field(o.communityitemid, 1) +} + +return res +} + +pub fn cplayersetanimatedavatarrequest_unpack(buf []byte) ?CPlayerSetAnimatedAvatarRequest { +mut res := CPlayerSetAnimatedAvatarRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_communityitemid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.communityitemid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayersetanimatedavatarrequest() CPlayerSetAnimatedAvatarRequest { +return CPlayerSetAnimatedAvatarRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayersetanimatedavatarrequest(o CPlayerSetAnimatedAvatarRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayersetanimatedavatarrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerSetAnimatedAvatarRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayersetanimatedavatarrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerSetAnimatedAvatarResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPlayerSetAnimatedAvatarResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cplayersetanimatedavatarresponse_unpack(buf []byte) ?CPlayerSetAnimatedAvatarResponse { +res := CPlayerSetAnimatedAvatarResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayersetanimatedavatarresponse() CPlayerSetAnimatedAvatarResponse { +return CPlayerSetAnimatedAvatarResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayersetanimatedavatarresponse(o CPlayerSetAnimatedAvatarResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayersetanimatedavatarresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerSetAnimatedAvatarResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayersetanimatedavatarresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetProfileItemsOwnedRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +language string +has_language bool +} +pub fn (o &CPlayerGetProfileItemsOwnedRequest) pack() []byte { +mut res := []byte{} +if o.has_language { +res << vproto.pack_string_field(o.language, 1) +} + +return res +} + +pub fn cplayergetprofileitemsownedrequest_unpack(buf []byte) ?CPlayerGetProfileItemsOwnedRequest { +mut res := CPlayerGetProfileItemsOwnedRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_language = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetprofileitemsownedrequest() CPlayerGetProfileItemsOwnedRequest { +return CPlayerGetProfileItemsOwnedRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetprofileitemsownedrequest(o CPlayerGetProfileItemsOwnedRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetprofileitemsownedrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetProfileItemsOwnedRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetprofileitemsownedrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetProfileItemsOwnedResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +profile_backgrounds []ProfileItem +mini_profile_backgrounds []ProfileItem +avatar_frames []ProfileItem +animated_avatars []ProfileItem +profile_modifiers []ProfileItem +} +pub fn (o &CPlayerGetProfileItemsOwnedResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.profile_backgrounds { +res << zzz_vproto_internal_pack_profileitem(x, 1) +} + +// [packed=false] +for _, x in o.mini_profile_backgrounds { +res << zzz_vproto_internal_pack_profileitem(x, 2) +} + +// [packed=false] +for _, x in o.avatar_frames { +res << zzz_vproto_internal_pack_profileitem(x, 3) +} + +// [packed=false] +for _, x in o.animated_avatars { +res << zzz_vproto_internal_pack_profileitem(x, 4) +} + +// [packed=false] +for _, x in o.profile_modifiers { +res << zzz_vproto_internal_pack_profileitem(x, 5) +} + +return res +} + +pub fn cplayergetprofileitemsownedresponse_unpack(buf []byte) ?CPlayerGetProfileItemsOwnedResponse { +mut res := CPlayerGetProfileItemsOwnedResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_profileitem(cur_buf, tag_wiretype.wire_type)? +res.profile_backgrounds << v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_profileitem(cur_buf, tag_wiretype.wire_type)? +res.mini_profile_backgrounds << v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_profileitem(cur_buf, tag_wiretype.wire_type)? +res.avatar_frames << v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_profileitem(cur_buf, tag_wiretype.wire_type)? +res.animated_avatars << v +i = ii +} + +5 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_profileitem(cur_buf, tag_wiretype.wire_type)? +res.profile_modifiers << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetprofileitemsownedresponse() CPlayerGetProfileItemsOwnedResponse { +return CPlayerGetProfileItemsOwnedResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetprofileitemsownedresponse(o CPlayerGetProfileItemsOwnedResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetprofileitemsownedresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetProfileItemsOwnedResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetprofileitemsownedresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetProfileItemsEquippedRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +language string +has_language bool +} +pub fn (o &CPlayerGetProfileItemsEquippedRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_language { +res << vproto.pack_string_field(o.language, 2) +} + +return res +} + +pub fn cplayergetprofileitemsequippedrequest_unpack(buf []byte) ?CPlayerGetProfileItemsEquippedRequest { +mut res := CPlayerGetProfileItemsEquippedRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_language = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetprofileitemsequippedrequest() CPlayerGetProfileItemsEquippedRequest { +return CPlayerGetProfileItemsEquippedRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetprofileitemsequippedrequest(o CPlayerGetProfileItemsEquippedRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetprofileitemsequippedrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetProfileItemsEquippedRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetprofileitemsequippedrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetProfileItemsEquippedResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +profile_background ProfileItem +has_profile_background bool +mini_profile_background ProfileItem +has_mini_profile_background bool +avatar_frame ProfileItem +has_avatar_frame bool +animated_avatar ProfileItem +has_animated_avatar bool +profile_modifier ProfileItem +has_profile_modifier bool +} +pub fn (o &CPlayerGetProfileItemsEquippedResponse) pack() []byte { +mut res := []byte{} +if o.has_profile_background { +res << zzz_vproto_internal_pack_profileitem(o.profile_background, 1) +} + +if o.has_mini_profile_background { +res << zzz_vproto_internal_pack_profileitem(o.mini_profile_background, 2) +} + +if o.has_avatar_frame { +res << zzz_vproto_internal_pack_profileitem(o.avatar_frame, 3) +} + +if o.has_animated_avatar { +res << zzz_vproto_internal_pack_profileitem(o.animated_avatar, 4) +} + +if o.has_profile_modifier { +res << zzz_vproto_internal_pack_profileitem(o.profile_modifier, 5) +} + +return res +} + +pub fn cplayergetprofileitemsequippedresponse_unpack(buf []byte) ?CPlayerGetProfileItemsEquippedResponse { +mut res := CPlayerGetProfileItemsEquippedResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_profile_background = true +ii, v := zzz_vproto_internal_unpack_profileitem(cur_buf, tag_wiretype.wire_type)? +res.profile_background = v +i = ii +} + +2 { +res.has_mini_profile_background = true +ii, v := zzz_vproto_internal_unpack_profileitem(cur_buf, tag_wiretype.wire_type)? +res.mini_profile_background = v +i = ii +} + +3 { +res.has_avatar_frame = true +ii, v := zzz_vproto_internal_unpack_profileitem(cur_buf, tag_wiretype.wire_type)? +res.avatar_frame = v +i = ii +} + +4 { +res.has_animated_avatar = true +ii, v := zzz_vproto_internal_unpack_profileitem(cur_buf, tag_wiretype.wire_type)? +res.animated_avatar = v +i = ii +} + +5 { +res.has_profile_modifier = true +ii, v := zzz_vproto_internal_unpack_profileitem(cur_buf, tag_wiretype.wire_type)? +res.profile_modifier = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetprofileitemsequippedresponse() CPlayerGetProfileItemsEquippedResponse { +return CPlayerGetProfileItemsEquippedResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetprofileitemsequippedresponse(o CPlayerGetProfileItemsEquippedResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetprofileitemsequippedresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetProfileItemsEquippedResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetprofileitemsequippedresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerSetEquippedProfileItemFlagsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +communityitemid u64 +has_communityitemid bool +flags u32 +has_flags bool +} +pub fn (o &CPlayerSetEquippedProfileItemFlagsRequest) pack() []byte { +mut res := []byte{} +if o.has_communityitemid { +res << vproto.pack_uint64_field(o.communityitemid, 1) +} + +if o.has_flags { +res << vproto.pack_uint32_field(o.flags, 2) +} + +return res +} + +pub fn cplayersetequippedprofileitemflagsrequest_unpack(buf []byte) ?CPlayerSetEquippedProfileItemFlagsRequest { +mut res := CPlayerSetEquippedProfileItemFlagsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_communityitemid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.communityitemid = v +i = ii +} + +2 { +res.has_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.flags = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayersetequippedprofileitemflagsrequest() CPlayerSetEquippedProfileItemFlagsRequest { +return CPlayerSetEquippedProfileItemFlagsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayersetequippedprofileitemflagsrequest(o CPlayerSetEquippedProfileItemFlagsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayersetequippedprofileitemflagsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerSetEquippedProfileItemFlagsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayersetequippedprofileitemflagsrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerSetEquippedProfileItemFlagsResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPlayerSetEquippedProfileItemFlagsResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cplayersetequippedprofileitemflagsresponse_unpack(buf []byte) ?CPlayerSetEquippedProfileItemFlagsResponse { +res := CPlayerSetEquippedProfileItemFlagsResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayersetequippedprofileitemflagsresponse() CPlayerSetEquippedProfileItemFlagsResponse { +return CPlayerSetEquippedProfileItemFlagsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayersetequippedprofileitemflagsresponse(o CPlayerSetEquippedProfileItemFlagsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayersetequippedprofileitemflagsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerSetEquippedProfileItemFlagsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayersetequippedprofileitemflagsresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetEmoticonListRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPlayerGetEmoticonListRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn cplayergetemoticonlistrequest_unpack(buf []byte) ?CPlayerGetEmoticonListRequest { +res := CPlayerGetEmoticonListRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetemoticonlistrequest() CPlayerGetEmoticonListRequest { +return CPlayerGetEmoticonListRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetemoticonlistrequest(o CPlayerGetEmoticonListRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetemoticonlistrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetEmoticonListRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetemoticonlistrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetEmoticonListResponseEmoticon { +mut: +unknown_fields []vproto.UnknownField +pub mut: +name string +has_name bool +count int +has_count bool +time_last_used u32 +has_time_last_used bool +use_count u32 +has_use_count bool +time_received u32 +has_time_received bool +} +pub fn (o &CPlayerGetEmoticonListResponseEmoticon) pack() []byte { +mut res := []byte{} +if o.has_name { +res << vproto.pack_string_field(o.name, 1) +} + +if o.has_count { +res << vproto.pack_int32_field(o.count, 2) +} + +if o.has_time_last_used { +res << vproto.pack_uint32_field(o.time_last_used, 3) +} + +if o.has_use_count { +res << vproto.pack_uint32_field(o.use_count, 4) +} + +if o.has_time_received { +res << vproto.pack_uint32_field(o.time_received, 5) +} + +return res +} + +pub fn cplayergetemoticonlistresponseemoticon_unpack(buf []byte) ?CPlayerGetEmoticonListResponseEmoticon { +mut res := CPlayerGetEmoticonListResponseEmoticon{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +2 { +res.has_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.count = v +i = ii +} + +3 { +res.has_time_last_used = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_last_used = v +i = ii +} + +4 { +res.has_use_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.use_count = v +i = ii +} + +5 { +res.has_time_received = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_received = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetemoticonlistresponseemoticon() CPlayerGetEmoticonListResponseEmoticon { +return CPlayerGetEmoticonListResponseEmoticon{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetemoticonlistresponseemoticon(o CPlayerGetEmoticonListResponseEmoticon, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetemoticonlistresponseemoticon(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetEmoticonListResponseEmoticon) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetemoticonlistresponseemoticon_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetEmoticonListResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +emoticons []CPlayerGetEmoticonListResponseEmoticon +} +pub fn (o &CPlayerGetEmoticonListResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.emoticons { +res << zzz_vproto_internal_pack_cplayergetemoticonlistresponseemoticon(x, 1) +} + +return res +} + +pub fn cplayergetemoticonlistresponse_unpack(buf []byte) ?CPlayerGetEmoticonListResponse { +mut res := CPlayerGetEmoticonListResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cplayergetemoticonlistresponseemoticon(cur_buf, tag_wiretype.wire_type)? +res.emoticons << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetemoticonlistresponse() CPlayerGetEmoticonListResponse { +return CPlayerGetEmoticonListResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetemoticonlistresponse(o CPlayerGetEmoticonListResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetemoticonlistresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetEmoticonListResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetemoticonlistresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetAchievementsProgressRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +language string +has_language bool +appids []u32 +} +pub fn (o &CPlayerGetAchievementsProgressRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_uint64_field(o.steamid, 1) +} + +if o.has_language { +res << vproto.pack_string_field(o.language, 2) +} + +// [packed=false] +for _, x in o.appids { +res << vproto.pack_uint32_field(x, 3) +} + +return res +} + +pub fn cplayergetachievementsprogressrequest_unpack(buf []byte) ?CPlayerGetAchievementsProgressRequest { +mut res := CPlayerGetAchievementsProgressRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_language = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +3 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetachievementsprogressrequest() CPlayerGetAchievementsProgressRequest { +return CPlayerGetAchievementsProgressRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetachievementsprogressrequest(o CPlayerGetAchievementsProgressRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetachievementsprogressrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetAchievementsProgressRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetachievementsprogressrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetAchievementsProgressResponseAchievementProgress { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +unlocked u32 +has_unlocked bool +total u32 +has_total bool +percentage f32 +has_percentage bool +all_unlocked bool +has_all_unlocked bool +cache_time u32 +has_cache_time bool +} +pub fn (o &CPlayerGetAchievementsProgressResponseAchievementProgress) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_unlocked { +res << vproto.pack_uint32_field(o.unlocked, 2) +} + +if o.has_total { +res << vproto.pack_uint32_field(o.total, 3) +} + +if o.has_percentage { +res << vproto.pack_float_field(o.percentage, 4) +} + +if o.has_all_unlocked { +res << vproto.pack_bool_field(o.all_unlocked, 5) +} + +if o.has_cache_time { +res << vproto.pack_uint32_field(o.cache_time, 6) +} + +return res +} + +pub fn cplayergetachievementsprogressresponseachievementprogress_unpack(buf []byte) ?CPlayerGetAchievementsProgressResponseAchievementProgress { +mut res := CPlayerGetAchievementsProgressResponseAchievementProgress{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_unlocked = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.unlocked = v +i = ii +} + +3 { +res.has_total = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.total = v +i = ii +} + +4 { +res.has_percentage = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.percentage = v +i = ii +} + +5 { +res.has_all_unlocked = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.all_unlocked = v +i = ii +} + +6 { +res.has_cache_time = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cache_time = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetachievementsprogressresponseachievementprogress() CPlayerGetAchievementsProgressResponseAchievementProgress { +return CPlayerGetAchievementsProgressResponseAchievementProgress{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetachievementsprogressresponseachievementprogress(o CPlayerGetAchievementsProgressResponseAchievementProgress, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetachievementsprogressresponseachievementprogress(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetAchievementsProgressResponseAchievementProgress) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetachievementsprogressresponseachievementprogress_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetAchievementsProgressResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +achievement_progress []CPlayerGetAchievementsProgressResponseAchievementProgress +} +pub fn (o &CPlayerGetAchievementsProgressResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.achievement_progress { +res << zzz_vproto_internal_pack_cplayergetachievementsprogressresponseachievementprogress(x, 1) +} + +return res +} + +pub fn cplayergetachievementsprogressresponse_unpack(buf []byte) ?CPlayerGetAchievementsProgressResponse { +mut res := CPlayerGetAchievementsProgressResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cplayergetachievementsprogressresponseachievementprogress(cur_buf, tag_wiretype.wire_type)? +res.achievement_progress << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetachievementsprogressresponse() CPlayerGetAchievementsProgressResponse { +return CPlayerGetAchievementsProgressResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetachievementsprogressresponse(o CPlayerGetAchievementsProgressResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetachievementsprogressresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetAchievementsProgressResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetachievementsprogressresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerPostStatusToFriendsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +status_text string +has_status_text bool +} +pub fn (o &CPlayerPostStatusToFriendsRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_status_text { +res << vproto.pack_string_field(o.status_text, 2) +} + +return res +} + +pub fn cplayerpoststatustofriendsrequest_unpack(buf []byte) ?CPlayerPostStatusToFriendsRequest { +mut res := CPlayerPostStatusToFriendsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_status_text = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.status_text = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayerpoststatustofriendsrequest() CPlayerPostStatusToFriendsRequest { +return CPlayerPostStatusToFriendsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayerpoststatustofriendsrequest(o CPlayerPostStatusToFriendsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayerpoststatustofriendsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerPostStatusToFriendsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayerpoststatustofriendsrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerPostStatusToFriendsResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPlayerPostStatusToFriendsResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cplayerpoststatustofriendsresponse_unpack(buf []byte) ?CPlayerPostStatusToFriendsResponse { +res := CPlayerPostStatusToFriendsResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayerpoststatustofriendsresponse() CPlayerPostStatusToFriendsResponse { +return CPlayerPostStatusToFriendsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayerpoststatustofriendsresponse(o CPlayerPostStatusToFriendsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayerpoststatustofriendsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerPostStatusToFriendsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayerpoststatustofriendsresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetPostedStatusRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +postid u64 +has_postid bool +} +pub fn (o &CPlayerGetPostedStatusRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_uint64_field(o.steamid, 1) +} + +if o.has_postid { +res << vproto.pack_uint64_field(o.postid, 2) +} + +return res +} + +pub fn cplayergetpostedstatusrequest_unpack(buf []byte) ?CPlayerGetPostedStatusRequest { +mut res := CPlayerGetPostedStatusRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_postid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.postid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetpostedstatusrequest() CPlayerGetPostedStatusRequest { +return CPlayerGetPostedStatusRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetpostedstatusrequest(o CPlayerGetPostedStatusRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetpostedstatusrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetPostedStatusRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetpostedstatusrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetPostedStatusResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +accountid u32 +has_accountid bool +postid u64 +has_postid bool +status_text string +has_status_text bool +deleted bool +has_deleted bool +appid u32 +has_appid bool +} +pub fn (o &CPlayerGetPostedStatusResponse) pack() []byte { +mut res := []byte{} +if o.has_accountid { +res << vproto.pack_uint32_field(o.accountid, 1) +} + +if o.has_postid { +res << vproto.pack_uint64_field(o.postid, 2) +} + +if o.has_status_text { +res << vproto.pack_string_field(o.status_text, 3) +} + +if o.has_deleted { +res << vproto.pack_bool_field(o.deleted, 4) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 5) +} + +return res +} + +pub fn cplayergetpostedstatusresponse_unpack(buf []byte) ?CPlayerGetPostedStatusResponse { +mut res := CPlayerGetPostedStatusResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_accountid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.accountid = v +i = ii +} + +2 { +res.has_postid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.postid = v +i = ii +} + +3 { +res.has_status_text = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.status_text = v +i = ii +} + +4 { +res.has_deleted = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.deleted = v +i = ii +} + +5 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetpostedstatusresponse() CPlayerGetPostedStatusResponse { +return CPlayerGetPostedStatusResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetpostedstatusresponse(o CPlayerGetPostedStatusResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetpostedstatusresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetPostedStatusResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetpostedstatusresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerDeletePostedStatusRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +postid u64 +has_postid bool +} +pub fn (o &CPlayerDeletePostedStatusRequest) pack() []byte { +mut res := []byte{} +if o.has_postid { +res << vproto.pack_uint64_field(o.postid, 1) +} + +return res +} + +pub fn cplayerdeletepostedstatusrequest_unpack(buf []byte) ?CPlayerDeletePostedStatusRequest { +mut res := CPlayerDeletePostedStatusRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_postid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.postid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayerdeletepostedstatusrequest() CPlayerDeletePostedStatusRequest { +return CPlayerDeletePostedStatusRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayerdeletepostedstatusrequest(o CPlayerDeletePostedStatusRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayerdeletepostedstatusrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerDeletePostedStatusRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayerdeletepostedstatusrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerDeletePostedStatusResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPlayerDeletePostedStatusResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cplayerdeletepostedstatusresponse_unpack(buf []byte) ?CPlayerDeletePostedStatusResponse { +res := CPlayerDeletePostedStatusResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayerdeletepostedstatusresponse() CPlayerDeletePostedStatusResponse { +return CPlayerDeletePostedStatusResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayerdeletepostedstatusresponse(o CPlayerDeletePostedStatusResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayerdeletepostedstatusresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerDeletePostedStatusResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayerdeletepostedstatusresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetLastPlayedTimesRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +min_last_played u32 +has_min_last_played bool +} +pub fn (o &CPlayerGetLastPlayedTimesRequest) pack() []byte { +mut res := []byte{} +if o.has_min_last_played { +res << vproto.pack_uint32_field(o.min_last_played, 1) +} + +return res +} + +pub fn cplayergetlastplayedtimesrequest_unpack(buf []byte) ?CPlayerGetLastPlayedTimesRequest { +mut res := CPlayerGetLastPlayedTimesRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_min_last_played = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.min_last_played = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetlastplayedtimesrequest() CPlayerGetLastPlayedTimesRequest { +return CPlayerGetLastPlayedTimesRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetlastplayedtimesrequest(o CPlayerGetLastPlayedTimesRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetlastplayedtimesrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetLastPlayedTimesRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetlastplayedtimesrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetLastPlayedTimesResponseGame { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid int +has_appid bool +last_playtime u32 +has_last_playtime bool +playtime_2weeks int +has_playtime_2weeks bool +playtime_forever int +has_playtime_forever bool +first_playtime u32 +has_first_playtime bool +playtime_windows_forever int +has_playtime_windows_forever bool +playtime_mac_forever int +has_playtime_mac_forever bool +playtime_linux_forever int +has_playtime_linux_forever bool +first_windows_playtime u32 +has_first_windows_playtime bool +first_mac_playtime u32 +has_first_mac_playtime bool +first_linux_playtime u32 +has_first_linux_playtime bool +last_windows_playtime u32 +has_last_windows_playtime bool +last_mac_playtime u32 +has_last_mac_playtime bool +last_linux_playtime u32 +has_last_linux_playtime bool +} +pub fn (o &CPlayerGetLastPlayedTimesResponseGame) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_int32_field(o.appid, 1) +} + +if o.has_last_playtime { +res << vproto.pack_uint32_field(o.last_playtime, 2) +} + +if o.has_playtime_2weeks { +res << vproto.pack_int32_field(o.playtime_2weeks, 3) +} + +if o.has_playtime_forever { +res << vproto.pack_int32_field(o.playtime_forever, 4) +} + +if o.has_first_playtime { +res << vproto.pack_uint32_field(o.first_playtime, 5) +} + +if o.has_playtime_windows_forever { +res << vproto.pack_int32_field(o.playtime_windows_forever, 6) +} + +if o.has_playtime_mac_forever { +res << vproto.pack_int32_field(o.playtime_mac_forever, 7) +} + +if o.has_playtime_linux_forever { +res << vproto.pack_int32_field(o.playtime_linux_forever, 8) +} + +if o.has_first_windows_playtime { +res << vproto.pack_uint32_field(o.first_windows_playtime, 9) +} + +if o.has_first_mac_playtime { +res << vproto.pack_uint32_field(o.first_mac_playtime, 10) +} + +if o.has_first_linux_playtime { +res << vproto.pack_uint32_field(o.first_linux_playtime, 11) +} + +if o.has_last_windows_playtime { +res << vproto.pack_uint32_field(o.last_windows_playtime, 12) +} + +if o.has_last_mac_playtime { +res << vproto.pack_uint32_field(o.last_mac_playtime, 13) +} + +if o.has_last_linux_playtime { +res << vproto.pack_uint32_field(o.last_linux_playtime, 14) +} + +return res +} + +pub fn cplayergetlastplayedtimesresponsegame_unpack(buf []byte) ?CPlayerGetLastPlayedTimesResponseGame { +mut res := CPlayerGetLastPlayedTimesResponseGame{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_last_playtime = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_playtime = v +i = ii +} + +3 { +res.has_playtime_2weeks = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.playtime_2weeks = v +i = ii +} + +4 { +res.has_playtime_forever = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.playtime_forever = v +i = ii +} + +5 { +res.has_first_playtime = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.first_playtime = v +i = ii +} + +6 { +res.has_playtime_windows_forever = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.playtime_windows_forever = v +i = ii +} + +7 { +res.has_playtime_mac_forever = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.playtime_mac_forever = v +i = ii +} + +8 { +res.has_playtime_linux_forever = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.playtime_linux_forever = v +i = ii +} + +9 { +res.has_first_windows_playtime = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.first_windows_playtime = v +i = ii +} + +10 { +res.has_first_mac_playtime = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.first_mac_playtime = v +i = ii +} + +11 { +res.has_first_linux_playtime = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.first_linux_playtime = v +i = ii +} + +12 { +res.has_last_windows_playtime = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_windows_playtime = v +i = ii +} + +13 { +res.has_last_mac_playtime = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_mac_playtime = v +i = ii +} + +14 { +res.has_last_linux_playtime = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_linux_playtime = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetlastplayedtimesresponsegame() CPlayerGetLastPlayedTimesResponseGame { +return CPlayerGetLastPlayedTimesResponseGame{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetlastplayedtimesresponsegame(o CPlayerGetLastPlayedTimesResponseGame, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetlastplayedtimesresponsegame(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetLastPlayedTimesResponseGame) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetlastplayedtimesresponsegame_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetLastPlayedTimesResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +games []CPlayerGetLastPlayedTimesResponseGame +} +pub fn (o &CPlayerGetLastPlayedTimesResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.games { +res << zzz_vproto_internal_pack_cplayergetlastplayedtimesresponsegame(x, 1) +} + +return res +} + +pub fn cplayergetlastplayedtimesresponse_unpack(buf []byte) ?CPlayerGetLastPlayedTimesResponse { +mut res := CPlayerGetLastPlayedTimesResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cplayergetlastplayedtimesresponsegame(cur_buf, tag_wiretype.wire_type)? +res.games << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetlastplayedtimesresponse() CPlayerGetLastPlayedTimesResponse { +return CPlayerGetLastPlayedTimesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetlastplayedtimesresponse(o CPlayerGetLastPlayedTimesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetlastplayedtimesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetLastPlayedTimesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetlastplayedtimesresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerAcceptSSarequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPlayerAcceptSSarequest) pack() []byte { +res := []byte{} +return res +} + +pub fn cplayeracceptssarequest_unpack(buf []byte) ?CPlayerAcceptSSarequest { +res := CPlayerAcceptSSarequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayeracceptssarequest() CPlayerAcceptSSarequest { +return CPlayerAcceptSSarequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayeracceptssarequest(o CPlayerAcceptSSarequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayeracceptssarequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerAcceptSSarequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayeracceptssarequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerAcceptSSaresponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPlayerAcceptSSaresponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cplayeracceptssaresponse_unpack(buf []byte) ?CPlayerAcceptSSaresponse { +res := CPlayerAcceptSSaresponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayeracceptssaresponse() CPlayerAcceptSSaresponse { +return CPlayerAcceptSSaresponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayeracceptssaresponse(o CPlayerAcceptSSaresponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayeracceptssaresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerAcceptSSaresponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayeracceptssaresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetNicknameListRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPlayerGetNicknameListRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn cplayergetnicknamelistrequest_unpack(buf []byte) ?CPlayerGetNicknameListRequest { +res := CPlayerGetNicknameListRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetnicknamelistrequest() CPlayerGetNicknameListRequest { +return CPlayerGetNicknameListRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetnicknamelistrequest(o CPlayerGetNicknameListRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetnicknamelistrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetNicknameListRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetnicknamelistrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetNicknameListResponsePlayerNickname { +mut: +unknown_fields []vproto.UnknownField +pub mut: +accountid u32 +has_accountid bool +nickname string +has_nickname bool +} +pub fn (o &CPlayerGetNicknameListResponsePlayerNickname) pack() []byte { +mut res := []byte{} +if o.has_accountid { +res << vproto.pack_32bit_field(o.accountid, 1) +} + +if o.has_nickname { +res << vproto.pack_string_field(o.nickname, 2) +} + +return res +} + +pub fn cplayergetnicknamelistresponseplayernickname_unpack(buf []byte) ?CPlayerGetNicknameListResponsePlayerNickname { +mut res := CPlayerGetNicknameListResponsePlayerNickname{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_accountid = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.accountid = v +i = ii +} + +2 { +res.has_nickname = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.nickname = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetnicknamelistresponseplayernickname() CPlayerGetNicknameListResponsePlayerNickname { +return CPlayerGetNicknameListResponsePlayerNickname{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetnicknamelistresponseplayernickname(o CPlayerGetNicknameListResponsePlayerNickname, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetnicknamelistresponseplayernickname(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetNicknameListResponsePlayerNickname) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetnicknamelistresponseplayernickname_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetNicknameListResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +nicknames []CPlayerGetNicknameListResponsePlayerNickname +} +pub fn (o &CPlayerGetNicknameListResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.nicknames { +res << zzz_vproto_internal_pack_cplayergetnicknamelistresponseplayernickname(x, 1) +} + +return res +} + +pub fn cplayergetnicknamelistresponse_unpack(buf []byte) ?CPlayerGetNicknameListResponse { +mut res := CPlayerGetNicknameListResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cplayergetnicknamelistresponseplayernickname(cur_buf, tag_wiretype.wire_type)? +res.nicknames << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetnicknamelistresponse() CPlayerGetNicknameListResponse { +return CPlayerGetNicknameListResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetnicknamelistresponse(o CPlayerGetNicknameListResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetnicknamelistresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetNicknameListResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetnicknamelistresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetPerFriendPreferencesRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPlayerGetPerFriendPreferencesRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn cplayergetperfriendpreferencesrequest_unpack(buf []byte) ?CPlayerGetPerFriendPreferencesRequest { +res := CPlayerGetPerFriendPreferencesRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetperfriendpreferencesrequest() CPlayerGetPerFriendPreferencesRequest { +return CPlayerGetPerFriendPreferencesRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetperfriendpreferencesrequest(o CPlayerGetPerFriendPreferencesRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetperfriendpreferencesrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetPerFriendPreferencesRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetperfriendpreferencesrequest_unpack(v)? +return i, unpacked +} +pub struct PerFriendPreferences { +mut: +unknown_fields []vproto.UnknownField +pub mut: +accountid u32 +has_accountid bool +nickname string +has_nickname bool +notifications_showingame ENotificationSetting +has_notifications_showingame bool +notifications_showonline ENotificationSetting +has_notifications_showonline bool +notifications_showmessages ENotificationSetting +has_notifications_showmessages bool +sounds_showingame ENotificationSetting +has_sounds_showingame bool +sounds_showonline ENotificationSetting +has_sounds_showonline bool +sounds_showmessages ENotificationSetting +has_sounds_showmessages bool +notifications_sendmobile ENotificationSetting +has_notifications_sendmobile bool +} +pub fn (o &PerFriendPreferences) pack() []byte { +mut res := []byte{} +if o.has_accountid { +res << vproto.pack_32bit_field(o.accountid, 1) +} + +if o.has_nickname { +res << vproto.pack_string_field(o.nickname, 2) +} + +if o.has_notifications_showingame { +res << zzz_vproto_internal_pack_enotificationsetting(o.notifications_showingame, 3) +} + +if o.has_notifications_showonline { +res << zzz_vproto_internal_pack_enotificationsetting(o.notifications_showonline, 4) +} + +if o.has_notifications_showmessages { +res << zzz_vproto_internal_pack_enotificationsetting(o.notifications_showmessages, 5) +} + +if o.has_sounds_showingame { +res << zzz_vproto_internal_pack_enotificationsetting(o.sounds_showingame, 6) +} + +if o.has_sounds_showonline { +res << zzz_vproto_internal_pack_enotificationsetting(o.sounds_showonline, 7) +} + +if o.has_sounds_showmessages { +res << zzz_vproto_internal_pack_enotificationsetting(o.sounds_showmessages, 8) +} + +if o.has_notifications_sendmobile { +res << zzz_vproto_internal_pack_enotificationsetting(o.notifications_sendmobile, 9) +} + +return res +} + +pub fn perfriendpreferences_unpack(buf []byte) ?PerFriendPreferences { +mut res := PerFriendPreferences{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_accountid = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.accountid = v +i = ii +} + +2 { +res.has_nickname = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.nickname = v +i = ii +} + +3 { +res.has_notifications_showingame = true +ii, v := zzz_vproto_internal_unpack_enotificationsetting(cur_buf, tag_wiretype.wire_type)? +res.notifications_showingame = v +i = ii +} + +4 { +res.has_notifications_showonline = true +ii, v := zzz_vproto_internal_unpack_enotificationsetting(cur_buf, tag_wiretype.wire_type)? +res.notifications_showonline = v +i = ii +} + +5 { +res.has_notifications_showmessages = true +ii, v := zzz_vproto_internal_unpack_enotificationsetting(cur_buf, tag_wiretype.wire_type)? +res.notifications_showmessages = v +i = ii +} + +6 { +res.has_sounds_showingame = true +ii, v := zzz_vproto_internal_unpack_enotificationsetting(cur_buf, tag_wiretype.wire_type)? +res.sounds_showingame = v +i = ii +} + +7 { +res.has_sounds_showonline = true +ii, v := zzz_vproto_internal_unpack_enotificationsetting(cur_buf, tag_wiretype.wire_type)? +res.sounds_showonline = v +i = ii +} + +8 { +res.has_sounds_showmessages = true +ii, v := zzz_vproto_internal_unpack_enotificationsetting(cur_buf, tag_wiretype.wire_type)? +res.sounds_showmessages = v +i = ii +} + +9 { +res.has_notifications_sendmobile = true +ii, v := zzz_vproto_internal_unpack_enotificationsetting(cur_buf, tag_wiretype.wire_type)? +res.notifications_sendmobile = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_perfriendpreferences() PerFriendPreferences { +return PerFriendPreferences{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_perfriendpreferences(o PerFriendPreferences, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_perfriendpreferences(buf []byte, tag_wiretype vproto.WireType) ?(int, PerFriendPreferences) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := perfriendpreferences_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetPerFriendPreferencesResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +preferences []PerFriendPreferences +} +pub fn (o &CPlayerGetPerFriendPreferencesResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.preferences { +res << zzz_vproto_internal_pack_perfriendpreferences(x, 1) +} + +return res +} + +pub fn cplayergetperfriendpreferencesresponse_unpack(buf []byte) ?CPlayerGetPerFriendPreferencesResponse { +mut res := CPlayerGetPerFriendPreferencesResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_perfriendpreferences(cur_buf, tag_wiretype.wire_type)? +res.preferences << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetperfriendpreferencesresponse() CPlayerGetPerFriendPreferencesResponse { +return CPlayerGetPerFriendPreferencesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetperfriendpreferencesresponse(o CPlayerGetPerFriendPreferencesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetperfriendpreferencesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetPerFriendPreferencesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetperfriendpreferencesresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerSetPerFriendPreferencesRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +preferences PerFriendPreferences +has_preferences bool +} +pub fn (o &CPlayerSetPerFriendPreferencesRequest) pack() []byte { +mut res := []byte{} +if o.has_preferences { +res << zzz_vproto_internal_pack_perfriendpreferences(o.preferences, 1) +} + +return res +} + +pub fn cplayersetperfriendpreferencesrequest_unpack(buf []byte) ?CPlayerSetPerFriendPreferencesRequest { +mut res := CPlayerSetPerFriendPreferencesRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_preferences = true +ii, v := zzz_vproto_internal_unpack_perfriendpreferences(cur_buf, tag_wiretype.wire_type)? +res.preferences = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayersetperfriendpreferencesrequest() CPlayerSetPerFriendPreferencesRequest { +return CPlayerSetPerFriendPreferencesRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayersetperfriendpreferencesrequest(o CPlayerSetPerFriendPreferencesRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayersetperfriendpreferencesrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerSetPerFriendPreferencesRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayersetperfriendpreferencesrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerSetPerFriendPreferencesResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPlayerSetPerFriendPreferencesResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cplayersetperfriendpreferencesresponse_unpack(buf []byte) ?CPlayerSetPerFriendPreferencesResponse { +res := CPlayerSetPerFriendPreferencesResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayersetperfriendpreferencesresponse() CPlayerSetPerFriendPreferencesResponse { +return CPlayerSetPerFriendPreferencesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayersetperfriendpreferencesresponse(o CPlayerSetPerFriendPreferencesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayersetperfriendpreferencesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerSetPerFriendPreferencesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayersetperfriendpreferencesresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerAddFriendRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +} +pub fn (o &CPlayerAddFriendRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +return res +} + +pub fn cplayeraddfriendrequest_unpack(buf []byte) ?CPlayerAddFriendRequest { +mut res := CPlayerAddFriendRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayeraddfriendrequest() CPlayerAddFriendRequest { +return CPlayerAddFriendRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayeraddfriendrequest(o CPlayerAddFriendRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayeraddfriendrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerAddFriendRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayeraddfriendrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerAddFriendResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +invite_sent bool +has_invite_sent bool +friend_relationship u32 +has_friend_relationship bool +result int +has_result bool +} +pub fn (o &CPlayerAddFriendResponse) pack() []byte { +mut res := []byte{} +if o.has_invite_sent { +res << vproto.pack_bool_field(o.invite_sent, 1) +} + +if o.has_friend_relationship { +res << vproto.pack_uint32_field(o.friend_relationship, 2) +} + +if o.has_result { +res << vproto.pack_int32_field(o.result, 3) +} + +return res +} + +pub fn cplayeraddfriendresponse_unpack(buf []byte) ?CPlayerAddFriendResponse { +mut res := CPlayerAddFriendResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_invite_sent = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.invite_sent = v +i = ii +} + +2 { +res.has_friend_relationship = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.friend_relationship = v +i = ii +} + +3 { +res.has_result = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.result = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayeraddfriendresponse() CPlayerAddFriendResponse { +return CPlayerAddFriendResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayeraddfriendresponse(o CPlayerAddFriendResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayeraddfriendresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerAddFriendResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayeraddfriendresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerRemoveFriendRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +} +pub fn (o &CPlayerRemoveFriendRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +return res +} + +pub fn cplayerremovefriendrequest_unpack(buf []byte) ?CPlayerRemoveFriendRequest { +mut res := CPlayerRemoveFriendRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayerremovefriendrequest() CPlayerRemoveFriendRequest { +return CPlayerRemoveFriendRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayerremovefriendrequest(o CPlayerRemoveFriendRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayerremovefriendrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerRemoveFriendRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayerremovefriendrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerRemoveFriendResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +friend_relationship u32 +has_friend_relationship bool +} +pub fn (o &CPlayerRemoveFriendResponse) pack() []byte { +mut res := []byte{} +if o.has_friend_relationship { +res << vproto.pack_uint32_field(o.friend_relationship, 1) +} + +return res +} + +pub fn cplayerremovefriendresponse_unpack(buf []byte) ?CPlayerRemoveFriendResponse { +mut res := CPlayerRemoveFriendResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_friend_relationship = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.friend_relationship = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayerremovefriendresponse() CPlayerRemoveFriendResponse { +return CPlayerRemoveFriendResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayerremovefriendresponse(o CPlayerRemoveFriendResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayerremovefriendresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerRemoveFriendResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayerremovefriendresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerIgnoreFriendRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +unignore bool +has_unignore bool +} +pub fn (o &CPlayerIgnoreFriendRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_unignore { +res << vproto.pack_bool_field(o.unignore, 2) +} + +return res +} + +pub fn cplayerignorefriendrequest_unpack(buf []byte) ?CPlayerIgnoreFriendRequest { +mut res := CPlayerIgnoreFriendRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_unignore = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.unignore = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayerignorefriendrequest() CPlayerIgnoreFriendRequest { +return CPlayerIgnoreFriendRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayerignorefriendrequest(o CPlayerIgnoreFriendRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayerignorefriendrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerIgnoreFriendRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayerignorefriendrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerIgnoreFriendResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +friend_relationship u32 +has_friend_relationship bool +} +pub fn (o &CPlayerIgnoreFriendResponse) pack() []byte { +mut res := []byte{} +if o.has_friend_relationship { +res << vproto.pack_uint32_field(o.friend_relationship, 1) +} + +return res +} + +pub fn cplayerignorefriendresponse_unpack(buf []byte) ?CPlayerIgnoreFriendResponse { +mut res := CPlayerIgnoreFriendResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_friend_relationship = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.friend_relationship = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayerignorefriendresponse() CPlayerIgnoreFriendResponse { +return CPlayerIgnoreFriendResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayerignorefriendresponse(o CPlayerIgnoreFriendResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayerignorefriendresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerIgnoreFriendResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayerignorefriendresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetCommunityPreferencesRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPlayerGetCommunityPreferencesRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn cplayergetcommunitypreferencesrequest_unpack(buf []byte) ?CPlayerGetCommunityPreferencesRequest { +res := CPlayerGetCommunityPreferencesRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetcommunitypreferencesrequest() CPlayerGetCommunityPreferencesRequest { +return CPlayerGetCommunityPreferencesRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetcommunitypreferencesrequest(o CPlayerGetCommunityPreferencesRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetcommunitypreferencesrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetCommunityPreferencesRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetcommunitypreferencesrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerCommunityPreferences { +mut: +unknown_fields []vproto.UnknownField +pub mut: +hide_adult_content_violence bool +has_hide_adult_content_violence bool +hide_adult_content_sex bool +has_hide_adult_content_sex bool +parenthesize_nicknames bool +has_parenthesize_nicknames bool +timestamp_updated u32 +has_timestamp_updated bool +} +pub fn (o &CPlayerCommunityPreferences) pack() []byte { +mut res := []byte{} +if o.has_hide_adult_content_violence { +res << vproto.pack_bool_field(o.hide_adult_content_violence, 1) +} + +if o.has_hide_adult_content_sex { +res << vproto.pack_bool_field(o.hide_adult_content_sex, 2) +} + +if o.has_parenthesize_nicknames { +res << vproto.pack_bool_field(o.parenthesize_nicknames, 4) +} + +if o.has_timestamp_updated { +res << vproto.pack_uint32_field(o.timestamp_updated, 3) +} + +return res +} + +pub fn cplayercommunitypreferences_unpack(buf []byte) ?CPlayerCommunityPreferences { +mut res := CPlayerCommunityPreferences{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_hide_adult_content_violence = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.hide_adult_content_violence = v +i = ii +} + +2 { +res.has_hide_adult_content_sex = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.hide_adult_content_sex = v +i = ii +} + +4 { +res.has_parenthesize_nicknames = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.parenthesize_nicknames = v +i = ii +} + +3 { +res.has_timestamp_updated = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp_updated = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayercommunitypreferences() CPlayerCommunityPreferences { +return CPlayerCommunityPreferences{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayercommunitypreferences(o CPlayerCommunityPreferences, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayercommunitypreferences(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerCommunityPreferences) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayercommunitypreferences_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetCommunityPreferencesResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +preferences CPlayerCommunityPreferences +has_preferences bool +} +pub fn (o &CPlayerGetCommunityPreferencesResponse) pack() []byte { +mut res := []byte{} +if o.has_preferences { +res << zzz_vproto_internal_pack_cplayercommunitypreferences(o.preferences, 1) +} + +return res +} + +pub fn cplayergetcommunitypreferencesresponse_unpack(buf []byte) ?CPlayerGetCommunityPreferencesResponse { +mut res := CPlayerGetCommunityPreferencesResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_preferences = true +ii, v := zzz_vproto_internal_unpack_cplayercommunitypreferences(cur_buf, tag_wiretype.wire_type)? +res.preferences = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetcommunitypreferencesresponse() CPlayerGetCommunityPreferencesResponse { +return CPlayerGetCommunityPreferencesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetcommunitypreferencesresponse(o CPlayerGetCommunityPreferencesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetcommunitypreferencesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetCommunityPreferencesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetcommunitypreferencesresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerSetCommunityPreferencesRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +preferences CPlayerCommunityPreferences +has_preferences bool +} +pub fn (o &CPlayerSetCommunityPreferencesRequest) pack() []byte { +mut res := []byte{} +if o.has_preferences { +res << zzz_vproto_internal_pack_cplayercommunitypreferences(o.preferences, 1) +} + +return res +} + +pub fn cplayersetcommunitypreferencesrequest_unpack(buf []byte) ?CPlayerSetCommunityPreferencesRequest { +mut res := CPlayerSetCommunityPreferencesRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_preferences = true +ii, v := zzz_vproto_internal_unpack_cplayercommunitypreferences(cur_buf, tag_wiretype.wire_type)? +res.preferences = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayersetcommunitypreferencesrequest() CPlayerSetCommunityPreferencesRequest { +return CPlayerSetCommunityPreferencesRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayersetcommunitypreferencesrequest(o CPlayerSetCommunityPreferencesRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayersetcommunitypreferencesrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerSetCommunityPreferencesRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayersetcommunitypreferencesrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerSetCommunityPreferencesResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPlayerSetCommunityPreferencesResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cplayersetcommunitypreferencesresponse_unpack(buf []byte) ?CPlayerSetCommunityPreferencesResponse { +res := CPlayerSetCommunityPreferencesResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayersetcommunitypreferencesresponse() CPlayerSetCommunityPreferencesResponse { +return CPlayerSetCommunityPreferencesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayersetcommunitypreferencesresponse(o CPlayerSetCommunityPreferencesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayersetcommunitypreferencesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerSetCommunityPreferencesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayersetcommunitypreferencesresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetNewSteamAnnouncementStateRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +language int +has_language bool +} +pub fn (o &CPlayerGetNewSteamAnnouncementStateRequest) pack() []byte { +mut res := []byte{} +if o.has_language { +res << vproto.pack_int32_field(o.language, 1) +} + +return res +} + +pub fn cplayergetnewsteamannouncementstaterequest_unpack(buf []byte) ?CPlayerGetNewSteamAnnouncementStateRequest { +mut res := CPlayerGetNewSteamAnnouncementStateRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_language = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetnewsteamannouncementstaterequest() CPlayerGetNewSteamAnnouncementStateRequest { +return CPlayerGetNewSteamAnnouncementStateRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetnewsteamannouncementstaterequest(o CPlayerGetNewSteamAnnouncementStateRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetnewsteamannouncementstaterequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetNewSteamAnnouncementStateRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetnewsteamannouncementstaterequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetNewSteamAnnouncementStateResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +state int +has_state bool +announcement_headline string +has_announcement_headline bool +announcement_url string +has_announcement_url bool +time_posted u32 +has_time_posted bool +announcement_gid u64 +has_announcement_gid bool +} +pub fn (o &CPlayerGetNewSteamAnnouncementStateResponse) pack() []byte { +mut res := []byte{} +if o.has_state { +res << vproto.pack_int32_field(o.state, 1) +} + +if o.has_announcement_headline { +res << vproto.pack_string_field(o.announcement_headline, 2) +} + +if o.has_announcement_url { +res << vproto.pack_string_field(o.announcement_url, 3) +} + +if o.has_time_posted { +res << vproto.pack_uint32_field(o.time_posted, 4) +} + +if o.has_announcement_gid { +res << vproto.pack_uint64_field(o.announcement_gid, 5) +} + +return res +} + +pub fn cplayergetnewsteamannouncementstateresponse_unpack(buf []byte) ?CPlayerGetNewSteamAnnouncementStateResponse { +mut res := CPlayerGetNewSteamAnnouncementStateResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_state = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.state = v +i = ii +} + +2 { +res.has_announcement_headline = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.announcement_headline = v +i = ii +} + +3 { +res.has_announcement_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.announcement_url = v +i = ii +} + +4 { +res.has_time_posted = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_posted = v +i = ii +} + +5 { +res.has_announcement_gid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.announcement_gid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetnewsteamannouncementstateresponse() CPlayerGetNewSteamAnnouncementStateResponse { +return CPlayerGetNewSteamAnnouncementStateResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetnewsteamannouncementstateresponse(o CPlayerGetNewSteamAnnouncementStateResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetnewsteamannouncementstateresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetNewSteamAnnouncementStateResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetnewsteamannouncementstateresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerUpdateSteamAnnouncementLastReadRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +announcement_gid u64 +has_announcement_gid bool +time_posted u32 +has_time_posted bool +} +pub fn (o &CPlayerUpdateSteamAnnouncementLastReadRequest) pack() []byte { +mut res := []byte{} +if o.has_announcement_gid { +res << vproto.pack_uint64_field(o.announcement_gid, 1) +} + +if o.has_time_posted { +res << vproto.pack_uint32_field(o.time_posted, 2) +} + +return res +} + +pub fn cplayerupdatesteamannouncementlastreadrequest_unpack(buf []byte) ?CPlayerUpdateSteamAnnouncementLastReadRequest { +mut res := CPlayerUpdateSteamAnnouncementLastReadRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_announcement_gid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.announcement_gid = v +i = ii +} + +2 { +res.has_time_posted = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_posted = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayerupdatesteamannouncementlastreadrequest() CPlayerUpdateSteamAnnouncementLastReadRequest { +return CPlayerUpdateSteamAnnouncementLastReadRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayerupdatesteamannouncementlastreadrequest(o CPlayerUpdateSteamAnnouncementLastReadRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayerupdatesteamannouncementlastreadrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerUpdateSteamAnnouncementLastReadRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayerupdatesteamannouncementlastreadrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerUpdateSteamAnnouncementLastReadResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPlayerUpdateSteamAnnouncementLastReadResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cplayerupdatesteamannouncementlastreadresponse_unpack(buf []byte) ?CPlayerUpdateSteamAnnouncementLastReadResponse { +res := CPlayerUpdateSteamAnnouncementLastReadResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayerupdatesteamannouncementlastreadresponse() CPlayerUpdateSteamAnnouncementLastReadResponse { +return CPlayerUpdateSteamAnnouncementLastReadResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayerupdatesteamannouncementlastreadresponse(o CPlayerUpdateSteamAnnouncementLastReadResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayerupdatesteamannouncementlastreadresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerUpdateSteamAnnouncementLastReadResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayerupdatesteamannouncementlastreadresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetPrivacySettingsRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPlayerGetPrivacySettingsRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn cplayergetprivacysettingsrequest_unpack(buf []byte) ?CPlayerGetPrivacySettingsRequest { +res := CPlayerGetPrivacySettingsRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetprivacysettingsrequest() CPlayerGetPrivacySettingsRequest { +return CPlayerGetPrivacySettingsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetprivacysettingsrequest(o CPlayerGetPrivacySettingsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetprivacysettingsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetPrivacySettingsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetprivacysettingsrequest_unpack(v)? +return i, unpacked +} +pub struct CPrivacySettings { +mut: +unknown_fields []vproto.UnknownField +pub mut: +privacy_state int +has_privacy_state bool +privacy_state_inventory int +has_privacy_state_inventory bool +privacy_state_gifts int +has_privacy_state_gifts bool +privacy_state_ownedgames int +has_privacy_state_ownedgames bool +privacy_state_playtime int +has_privacy_state_playtime bool +privacy_state_friendslist int +has_privacy_state_friendslist bool +} +pub fn (o &CPrivacySettings) pack() []byte { +mut res := []byte{} +if o.has_privacy_state { +res << vproto.pack_int32_field(o.privacy_state, 1) +} + +if o.has_privacy_state_inventory { +res << vproto.pack_int32_field(o.privacy_state_inventory, 2) +} + +if o.has_privacy_state_gifts { +res << vproto.pack_int32_field(o.privacy_state_gifts, 3) +} + +if o.has_privacy_state_ownedgames { +res << vproto.pack_int32_field(o.privacy_state_ownedgames, 4) +} + +if o.has_privacy_state_playtime { +res << vproto.pack_int32_field(o.privacy_state_playtime, 5) +} + +if o.has_privacy_state_friendslist { +res << vproto.pack_int32_field(o.privacy_state_friendslist, 6) +} + +return res +} + +pub fn cprivacysettings_unpack(buf []byte) ?CPrivacySettings { +mut res := CPrivacySettings{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_privacy_state = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.privacy_state = v +i = ii +} + +2 { +res.has_privacy_state_inventory = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.privacy_state_inventory = v +i = ii +} + +3 { +res.has_privacy_state_gifts = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.privacy_state_gifts = v +i = ii +} + +4 { +res.has_privacy_state_ownedgames = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.privacy_state_ownedgames = v +i = ii +} + +5 { +res.has_privacy_state_playtime = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.privacy_state_playtime = v +i = ii +} + +6 { +res.has_privacy_state_friendslist = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.privacy_state_friendslist = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cprivacysettings() CPrivacySettings { +return CPrivacySettings{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cprivacysettings(o CPrivacySettings, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cprivacysettings(buf []byte, tag_wiretype vproto.WireType) ?(int, CPrivacySettings) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cprivacysettings_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetPrivacySettingsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +privacy_settings CPrivacySettings +has_privacy_settings bool +} +pub fn (o &CPlayerGetPrivacySettingsResponse) pack() []byte { +mut res := []byte{} +if o.has_privacy_settings { +res << zzz_vproto_internal_pack_cprivacysettings(o.privacy_settings, 1) +} + +return res +} + +pub fn cplayergetprivacysettingsresponse_unpack(buf []byte) ?CPlayerGetPrivacySettingsResponse { +mut res := CPlayerGetPrivacySettingsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_privacy_settings = true +ii, v := zzz_vproto_internal_unpack_cprivacysettings(cur_buf, tag_wiretype.wire_type)? +res.privacy_settings = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetprivacysettingsresponse() CPlayerGetPrivacySettingsResponse { +return CPlayerGetPrivacySettingsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetprivacysettingsresponse(o CPlayerGetPrivacySettingsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetprivacysettingsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetPrivacySettingsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetprivacysettingsresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetDurationControlRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +} +pub fn (o &CPlayerGetDurationControlRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +return res +} + +pub fn cplayergetdurationcontrolrequest_unpack(buf []byte) ?CPlayerGetDurationControlRequest { +mut res := CPlayerGetDurationControlRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetdurationcontrolrequest() CPlayerGetDurationControlRequest { +return CPlayerGetDurationControlRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetdurationcontrolrequest(o CPlayerGetDurationControlRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetdurationcontrolrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetDurationControlRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetdurationcontrolrequest_unpack(v)? +return i, unpacked +} +pub struct CPlayerGetDurationControlResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +is_enabled bool +has_is_enabled bool +seconds int +has_seconds bool +seconds_today int +has_seconds_today bool +is_steamchina_account bool +has_is_steamchina_account bool +is_age_verified bool +has_is_age_verified bool +seconds_allowed_today u32 +has_seconds_allowed_today bool +} +pub fn (o &CPlayerGetDurationControlResponse) pack() []byte { +mut res := []byte{} +if o.has_is_enabled { +res << vproto.pack_bool_field(o.is_enabled, 1) +} + +if o.has_seconds { +res << vproto.pack_int32_field(o.seconds, 2) +} + +if o.has_seconds_today { +res << vproto.pack_int32_field(o.seconds_today, 3) +} + +if o.has_is_steamchina_account { +res << vproto.pack_bool_field(o.is_steamchina_account, 4) +} + +if o.has_is_age_verified { +res << vproto.pack_bool_field(o.is_age_verified, 5) +} + +if o.has_seconds_allowed_today { +res << vproto.pack_uint32_field(o.seconds_allowed_today, 6) +} + +return res +} + +pub fn cplayergetdurationcontrolresponse_unpack(buf []byte) ?CPlayerGetDurationControlResponse { +mut res := CPlayerGetDurationControlResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_is_enabled = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_enabled = v +i = ii +} + +2 { +res.has_seconds = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds = v +i = ii +} + +3 { +res.has_seconds_today = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_today = v +i = ii +} + +4 { +res.has_is_steamchina_account = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_steamchina_account = v +i = ii +} + +5 { +res.has_is_age_verified = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_age_verified = v +i = ii +} + +6 { +res.has_seconds_allowed_today = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_allowed_today = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayergetdurationcontrolresponse() CPlayerGetDurationControlResponse { +return CPlayerGetDurationControlResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayergetdurationcontrolresponse(o CPlayerGetDurationControlResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayergetdurationcontrolresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerGetDurationControlResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayergetdurationcontrolresponse_unpack(v)? +return i, unpacked +} +pub struct CPlayerLastPlayedTimesNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +games []CPlayerGetLastPlayedTimesResponseGame +} +pub fn (o &CPlayerLastPlayedTimesNotification) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.games { +res << zzz_vproto_internal_pack_cplayergetlastplayedtimesresponsegame(x, 1) +} + +return res +} + +pub fn cplayerlastplayedtimesnotification_unpack(buf []byte) ?CPlayerLastPlayedTimesNotification { +mut res := CPlayerLastPlayedTimesNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cplayergetlastplayedtimesresponsegame(cur_buf, tag_wiretype.wire_type)? +res.games << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayerlastplayedtimesnotification() CPlayerLastPlayedTimesNotification { +return CPlayerLastPlayedTimesNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayerlastplayedtimesnotification(o CPlayerLastPlayedTimesNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayerlastplayedtimesnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerLastPlayedTimesNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayerlastplayedtimesnotification_unpack(v)? +return i, unpacked +} +pub struct CPlayerFriendNicknameChangedNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +accountid u32 +has_accountid bool +nickname string +has_nickname bool +is_echo_to_self bool +has_is_echo_to_self bool +} +pub fn (o &CPlayerFriendNicknameChangedNotification) pack() []byte { +mut res := []byte{} +if o.has_accountid { +res << vproto.pack_32bit_field(o.accountid, 1) +} + +if o.has_nickname { +res << vproto.pack_string_field(o.nickname, 2) +} + +if o.has_is_echo_to_self { +res << vproto.pack_bool_field(o.is_echo_to_self, 3) +} + +return res +} + +pub fn cplayerfriendnicknamechangednotification_unpack(buf []byte) ?CPlayerFriendNicknameChangedNotification { +mut res := CPlayerFriendNicknameChangedNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_accountid = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.accountid = v +i = ii +} + +2 { +res.has_nickname = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.nickname = v +i = ii +} + +3 { +res.has_is_echo_to_self = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_echo_to_self = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayerfriendnicknamechangednotification() CPlayerFriendNicknameChangedNotification { +return CPlayerFriendNicknameChangedNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayerfriendnicknamechangednotification(o CPlayerFriendNicknameChangedNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayerfriendnicknamechangednotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerFriendNicknameChangedNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayerfriendnicknamechangednotification_unpack(v)? +return i, unpacked +} +pub struct CPlayerFriendEquippedProfileItemsChangedNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +accountid u32 +has_accountid bool +} +pub fn (o &CPlayerFriendEquippedProfileItemsChangedNotification) pack() []byte { +mut res := []byte{} +if o.has_accountid { +res << vproto.pack_32bit_field(o.accountid, 1) +} + +return res +} + +pub fn cplayerfriendequippedprofileitemschangednotification_unpack(buf []byte) ?CPlayerFriendEquippedProfileItemsChangedNotification { +mut res := CPlayerFriendEquippedProfileItemsChangedNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_accountid = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.accountid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayerfriendequippedprofileitemschangednotification() CPlayerFriendEquippedProfileItemsChangedNotification { +return CPlayerFriendEquippedProfileItemsChangedNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayerfriendequippedprofileitemschangednotification(o CPlayerFriendEquippedProfileItemsChangedNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayerfriendequippedprofileitemschangednotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerFriendEquippedProfileItemsChangedNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayerfriendequippedprofileitemschangednotification_unpack(v)? +return i, unpacked +} +pub struct CPlayerNewSteamAnnouncementStateNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +state int +has_state bool +announcement_headline string +has_announcement_headline bool +announcement_url string +has_announcement_url bool +time_posted u32 +has_time_posted bool +announcement_gid u64 +has_announcement_gid bool +} +pub fn (o &CPlayerNewSteamAnnouncementStateNotification) pack() []byte { +mut res := []byte{} +if o.has_state { +res << vproto.pack_int32_field(o.state, 1) +} + +if o.has_announcement_headline { +res << vproto.pack_string_field(o.announcement_headline, 2) +} + +if o.has_announcement_url { +res << vproto.pack_string_field(o.announcement_url, 3) +} + +if o.has_time_posted { +res << vproto.pack_uint32_field(o.time_posted, 4) +} + +if o.has_announcement_gid { +res << vproto.pack_uint64_field(o.announcement_gid, 5) +} + +return res +} + +pub fn cplayernewsteamannouncementstatenotification_unpack(buf []byte) ?CPlayerNewSteamAnnouncementStateNotification { +mut res := CPlayerNewSteamAnnouncementStateNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_state = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.state = v +i = ii +} + +2 { +res.has_announcement_headline = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.announcement_headline = v +i = ii +} + +3 { +res.has_announcement_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.announcement_url = v +i = ii +} + +4 { +res.has_time_posted = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_posted = v +i = ii +} + +5 { +res.has_announcement_gid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.announcement_gid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayernewsteamannouncementstatenotification() CPlayerNewSteamAnnouncementStateNotification { +return CPlayerNewSteamAnnouncementStateNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayernewsteamannouncementstatenotification(o CPlayerNewSteamAnnouncementStateNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayernewsteamannouncementstatenotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerNewSteamAnnouncementStateNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayernewsteamannouncementstatenotification_unpack(v)? +return i, unpacked +} +pub struct CPlayerCommunityPreferencesChangedNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +preferences CPlayerCommunityPreferences +has_preferences bool +} +pub fn (o &CPlayerCommunityPreferencesChangedNotification) pack() []byte { +mut res := []byte{} +if o.has_preferences { +res << zzz_vproto_internal_pack_cplayercommunitypreferences(o.preferences, 1) +} + +return res +} + +pub fn cplayercommunitypreferenceschangednotification_unpack(buf []byte) ?CPlayerCommunityPreferencesChangedNotification { +mut res := CPlayerCommunityPreferencesChangedNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_preferences = true +ii, v := zzz_vproto_internal_unpack_cplayercommunitypreferences(cur_buf, tag_wiretype.wire_type)? +res.preferences = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayercommunitypreferenceschangednotification() CPlayerCommunityPreferencesChangedNotification { +return CPlayerCommunityPreferencesChangedNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayercommunitypreferenceschangednotification(o CPlayerCommunityPreferencesChangedNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayercommunitypreferenceschangednotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerCommunityPreferencesChangedNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayercommunitypreferenceschangednotification_unpack(v)? +return i, unpacked +} +pub struct CPlayerPerFriendPreferencesChangedNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +accountid u32 +has_accountid bool +preferences PerFriendPreferences +has_preferences bool +} +pub fn (o &CPlayerPerFriendPreferencesChangedNotification) pack() []byte { +mut res := []byte{} +if o.has_accountid { +res << vproto.pack_32bit_field(o.accountid, 1) +} + +if o.has_preferences { +res << zzz_vproto_internal_pack_perfriendpreferences(o.preferences, 2) +} + +return res +} + +pub fn cplayerperfriendpreferenceschangednotification_unpack(buf []byte) ?CPlayerPerFriendPreferencesChangedNotification { +mut res := CPlayerPerFriendPreferencesChangedNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_accountid = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.accountid = v +i = ii +} + +2 { +res.has_preferences = true +ii, v := zzz_vproto_internal_unpack_perfriendpreferences(cur_buf, tag_wiretype.wire_type)? +res.preferences = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayerperfriendpreferenceschangednotification() CPlayerPerFriendPreferencesChangedNotification { +return CPlayerPerFriendPreferencesChangedNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayerperfriendpreferenceschangednotification(o CPlayerPerFriendPreferencesChangedNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayerperfriendpreferenceschangednotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerPerFriendPreferencesChangedNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayerperfriendpreferenceschangednotification_unpack(v)? +return i, unpacked +} +pub struct CPlayerPrivacySettingsChangedNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +privacy_settings CPrivacySettings +has_privacy_settings bool +} +pub fn (o &CPlayerPrivacySettingsChangedNotification) pack() []byte { +mut res := []byte{} +if o.has_privacy_settings { +res << zzz_vproto_internal_pack_cprivacysettings(o.privacy_settings, 1) +} + +return res +} + +pub fn cplayerprivacysettingschangednotification_unpack(buf []byte) ?CPlayerPrivacySettingsChangedNotification { +mut res := CPlayerPrivacySettingsChangedNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_privacy_settings = true +ii, v := zzz_vproto_internal_unpack_cprivacysettings(cur_buf, tag_wiretype.wire_type)? +res.privacy_settings = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cplayerprivacysettingschangednotification() CPlayerPrivacySettingsChangedNotification { +return CPlayerPrivacySettingsChangedNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cplayerprivacysettingschangednotification(o CPlayerPrivacySettingsChangedNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cplayerprivacysettingschangednotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CPlayerPrivacySettingsChangedNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cplayerprivacysettingschangednotification_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_publishedfile.steamclient_pb.v b/proto/steammessages_publishedfile.steamclient_pb.v new file mode 100644 index 0000000..3800e76 --- /dev/null +++ b/proto/steammessages_publishedfile.steamclient_pb.v @@ -0,0 +1,7181 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +[_allow_multiple_values] +enum EPublishedFileRevision { +k_epublishedfilerevision_default = 0 +k_epublishedfilerevision_latest = 1 +k_epublishedfilerevision_approvedsnapshot = 2 +k_epublishedfilerevision_approvedsnapshot_china = 3 +k_epublishedfilerevision_rejectedsnapshot = 4 +k_epublishedfilerevision_rejectedsnapshot_china = 5 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_epublishedfilerevision(e EPublishedFileRevision, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_epublishedfilerevision(buf []byte, tag_wiretype vproto.WireType) ?(int, EPublishedFileRevision) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EPublishedFileRevision(v) +} +[_allow_multiple_values] +enum EPublishedFileForSaleStatus { +k_pffss_notforsale = 0 +k_pffss_pendingapproval = 1 +k_pffss_approvedforsale = 2 +k_pffss_rejectedforsale = 3 +k_pffss_nolongerforsale = 4 +k_pffss_tentativeapproval = 5 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_epublishedfileforsalestatus(e EPublishedFileForSaleStatus, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_epublishedfileforsalestatus(buf []byte, tag_wiretype vproto.WireType) ?(int, EPublishedFileForSaleStatus) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EPublishedFileForSaleStatus(v) +} +pub struct CPublishedFileSubscribeRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +publishedfileid u64 +has_publishedfileid bool +list_type u32 +has_list_type bool +appid int +has_appid bool +notify_client bool +has_notify_client bool +} +pub fn (o &CPublishedFileSubscribeRequest) pack() []byte { +mut res := []byte{} +if o.has_publishedfileid { +res << vproto.pack_uint64_field(o.publishedfileid, 1) +} + +if o.has_list_type { +res << vproto.pack_uint32_field(o.list_type, 2) +} + +if o.has_appid { +res << vproto.pack_int32_field(o.appid, 3) +} + +if o.has_notify_client { +res << vproto.pack_bool_field(o.notify_client, 4) +} + +return res +} + +pub fn cpublishedfilesubscriberequest_unpack(buf []byte) ?CPublishedFileSubscribeRequest { +mut res := CPublishedFileSubscribeRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_publishedfileid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.publishedfileid = v +i = ii +} + +2 { +res.has_list_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.list_type = v +i = ii +} + +3 { +res.has_appid = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +4 { +res.has_notify_client = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.notify_client = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilesubscriberequest() CPublishedFileSubscribeRequest { +return CPublishedFileSubscribeRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilesubscriberequest(o CPublishedFileSubscribeRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilesubscriberequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileSubscribeRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilesubscriberequest_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileSubscribeResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPublishedFileSubscribeResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cpublishedfilesubscriberesponse_unpack(buf []byte) ?CPublishedFileSubscribeResponse { +res := CPublishedFileSubscribeResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilesubscriberesponse() CPublishedFileSubscribeResponse { +return CPublishedFileSubscribeResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilesubscriberesponse(o CPublishedFileSubscribeResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilesubscriberesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileSubscribeResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilesubscriberesponse_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileUnsubscribeRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +publishedfileid u64 +has_publishedfileid bool +list_type u32 +has_list_type bool +appid int +has_appid bool +notify_client bool +has_notify_client bool +} +pub fn (o &CPublishedFileUnsubscribeRequest) pack() []byte { +mut res := []byte{} +if o.has_publishedfileid { +res << vproto.pack_uint64_field(o.publishedfileid, 1) +} + +if o.has_list_type { +res << vproto.pack_uint32_field(o.list_type, 2) +} + +if o.has_appid { +res << vproto.pack_int32_field(o.appid, 3) +} + +if o.has_notify_client { +res << vproto.pack_bool_field(o.notify_client, 4) +} + +return res +} + +pub fn cpublishedfileunsubscriberequest_unpack(buf []byte) ?CPublishedFileUnsubscribeRequest { +mut res := CPublishedFileUnsubscribeRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_publishedfileid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.publishedfileid = v +i = ii +} + +2 { +res.has_list_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.list_type = v +i = ii +} + +3 { +res.has_appid = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +4 { +res.has_notify_client = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.notify_client = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfileunsubscriberequest() CPublishedFileUnsubscribeRequest { +return CPublishedFileUnsubscribeRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfileunsubscriberequest(o CPublishedFileUnsubscribeRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfileunsubscriberequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileUnsubscribeRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfileunsubscriberequest_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileUnsubscribeResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPublishedFileUnsubscribeResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cpublishedfileunsubscriberesponse_unpack(buf []byte) ?CPublishedFileUnsubscribeResponse { +res := CPublishedFileUnsubscribeResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfileunsubscriberesponse() CPublishedFileUnsubscribeResponse { +return CPublishedFileUnsubscribeResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfileunsubscriberesponse(o CPublishedFileUnsubscribeResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfileunsubscriberesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileUnsubscribeResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfileunsubscriberesponse_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileCanSubscribeRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +publishedfileid u64 +has_publishedfileid bool +} +pub fn (o &CPublishedFileCanSubscribeRequest) pack() []byte { +mut res := []byte{} +if o.has_publishedfileid { +res << vproto.pack_uint64_field(o.publishedfileid, 1) +} + +return res +} + +pub fn cpublishedfilecansubscriberequest_unpack(buf []byte) ?CPublishedFileCanSubscribeRequest { +mut res := CPublishedFileCanSubscribeRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_publishedfileid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.publishedfileid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilecansubscriberequest() CPublishedFileCanSubscribeRequest { +return CPublishedFileCanSubscribeRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilecansubscriberequest(o CPublishedFileCanSubscribeRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilecansubscriberequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileCanSubscribeRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilecansubscriberequest_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileCanSubscribeResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +can_subscribe bool +has_can_subscribe bool +} +pub fn (o &CPublishedFileCanSubscribeResponse) pack() []byte { +mut res := []byte{} +if o.has_can_subscribe { +res << vproto.pack_bool_field(o.can_subscribe, 1) +} + +return res +} + +pub fn cpublishedfilecansubscriberesponse_unpack(buf []byte) ?CPublishedFileCanSubscribeResponse { +mut res := CPublishedFileCanSubscribeResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_can_subscribe = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.can_subscribe = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilecansubscriberesponse() CPublishedFileCanSubscribeResponse { +return CPublishedFileCanSubscribeResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilecansubscriberesponse(o CPublishedFileCanSubscribeResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilecansubscriberesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileCanSubscribeResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilecansubscriberesponse_unpack(v)? +return i, unpacked +} +pub struct CPublishedFilePublishRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +consumer_appid u32 +has_consumer_appid bool +cloudfilename string +has_cloudfilename bool +preview_cloudfilename string +has_preview_cloudfilename bool +title string +has_title bool +file_description string +has_file_description bool +file_type u32 +has_file_type bool +consumer_shortcut_name string +has_consumer_shortcut_name bool +youtube_username string +has_youtube_username bool +youtube_videoid string +has_youtube_videoid bool +visibility u32 +has_visibility bool +redirect_uri string +has_redirect_uri bool +tags []string +collection_type string +has_collection_type bool +game_type string +has_game_type bool +url string +has_url bool +} +pub fn (o &CPublishedFilePublishRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_consumer_appid { +res << vproto.pack_uint32_field(o.consumer_appid, 2) +} + +if o.has_cloudfilename { +res << vproto.pack_string_field(o.cloudfilename, 3) +} + +if o.has_preview_cloudfilename { +res << vproto.pack_string_field(o.preview_cloudfilename, 4) +} + +if o.has_title { +res << vproto.pack_string_field(o.title, 5) +} + +if o.has_file_description { +res << vproto.pack_string_field(o.file_description, 6) +} + +if o.has_file_type { +res << vproto.pack_uint32_field(o.file_type, 7) +} + +if o.has_consumer_shortcut_name { +res << vproto.pack_string_field(o.consumer_shortcut_name, 8) +} + +if o.has_youtube_username { +res << vproto.pack_string_field(o.youtube_username, 9) +} + +if o.has_youtube_videoid { +res << vproto.pack_string_field(o.youtube_videoid, 10) +} + +if o.has_visibility { +res << vproto.pack_uint32_field(o.visibility, 11) +} + +if o.has_redirect_uri { +res << vproto.pack_string_field(o.redirect_uri, 12) +} + +// [packed=false] +for _, x in o.tags { +res << vproto.pack_string_field(x, 13) +} + +if o.has_collection_type { +res << vproto.pack_string_field(o.collection_type, 14) +} + +if o.has_game_type { +res << vproto.pack_string_field(o.game_type, 15) +} + +if o.has_url { +res << vproto.pack_string_field(o.url, 16) +} + +return res +} + +pub fn cpublishedfilepublishrequest_unpack(buf []byte) ?CPublishedFilePublishRequest { +mut res := CPublishedFilePublishRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_consumer_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.consumer_appid = v +i = ii +} + +3 { +res.has_cloudfilename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.cloudfilename = v +i = ii +} + +4 { +res.has_preview_cloudfilename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.preview_cloudfilename = v +i = ii +} + +5 { +res.has_title = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.title = v +i = ii +} + +6 { +res.has_file_description = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.file_description = v +i = ii +} + +7 { +res.has_file_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.file_type = v +i = ii +} + +8 { +res.has_consumer_shortcut_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.consumer_shortcut_name = v +i = ii +} + +9 { +res.has_youtube_username = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.youtube_username = v +i = ii +} + +10 { +res.has_youtube_videoid = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.youtube_videoid = v +i = ii +} + +11 { +res.has_visibility = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.visibility = v +i = ii +} + +12 { +res.has_redirect_uri = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.redirect_uri = v +i = ii +} + +13 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.tags << v +i = ii +} + +14 { +res.has_collection_type = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.collection_type = v +i = ii +} + +15 { +res.has_game_type = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.game_type = v +i = ii +} + +16 { +res.has_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilepublishrequest() CPublishedFilePublishRequest { +return CPublishedFilePublishRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilepublishrequest(o CPublishedFilePublishRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilepublishrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFilePublishRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilepublishrequest_unpack(v)? +return i, unpacked +} +pub struct CPublishedFilePublishResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +publishedfileid u64 +has_publishedfileid bool +redirect_uri string +has_redirect_uri bool +} +pub fn (o &CPublishedFilePublishResponse) pack() []byte { +mut res := []byte{} +if o.has_publishedfileid { +res << vproto.pack_uint64_field(o.publishedfileid, 1) +} + +if o.has_redirect_uri { +res << vproto.pack_string_field(o.redirect_uri, 2) +} + +return res +} + +pub fn cpublishedfilepublishresponse_unpack(buf []byte) ?CPublishedFilePublishResponse { +mut res := CPublishedFilePublishResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_publishedfileid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.publishedfileid = v +i = ii +} + +2 { +res.has_redirect_uri = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.redirect_uri = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilepublishresponse() CPublishedFilePublishResponse { +return CPublishedFilePublishResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilepublishresponse(o CPublishedFilePublishResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilepublishresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFilePublishResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilepublishresponse_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileGetDetailsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +publishedfileids []u64 +includetags bool +has_includetags bool +includeadditionalpreviews bool +has_includeadditionalpreviews bool +includechildren bool +has_includechildren bool +includekvtags bool +has_includekvtags bool +includevotes bool +has_includevotes bool +short_description bool +has_short_description bool +includeforsaledata bool +has_includeforsaledata bool +includemetadata bool +has_includemetadata bool +language int +has_language bool +return_playtime_stats u32 +has_return_playtime_stats bool +appid u32 +has_appid bool +strip_description_bbcode bool +has_strip_description_bbcode bool +desired_revision EPublishedFileRevision +has_desired_revision bool +includereactions bool +has_includereactions bool +} +pub fn (o &CPublishedFileGetDetailsRequest) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.publishedfileids { +res << vproto.pack_64bit_field(x, 1) +} + +if o.has_includetags { +res << vproto.pack_bool_field(o.includetags, 2) +} + +if o.has_includeadditionalpreviews { +res << vproto.pack_bool_field(o.includeadditionalpreviews, 3) +} + +if o.has_includechildren { +res << vproto.pack_bool_field(o.includechildren, 4) +} + +if o.has_includekvtags { +res << vproto.pack_bool_field(o.includekvtags, 5) +} + +if o.has_includevotes { +res << vproto.pack_bool_field(o.includevotes, 6) +} + +if o.has_short_description { +res << vproto.pack_bool_field(o.short_description, 8) +} + +if o.has_includeforsaledata { +res << vproto.pack_bool_field(o.includeforsaledata, 10) +} + +if o.has_includemetadata { +res << vproto.pack_bool_field(o.includemetadata, 11) +} + +if o.has_language { +res << vproto.pack_int32_field(o.language, 12) +} + +if o.has_return_playtime_stats { +res << vproto.pack_uint32_field(o.return_playtime_stats, 13) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 14) +} + +if o.has_strip_description_bbcode { +res << vproto.pack_bool_field(o.strip_description_bbcode, 15) +} + +if o.has_desired_revision { +res << zzz_vproto_internal_pack_epublishedfilerevision(o.desired_revision, 16) +} + +if o.has_includereactions { +res << vproto.pack_bool_field(o.includereactions, 17) +} + +return res +} + +pub fn cpublishedfilegetdetailsrequest_unpack(buf []byte) ?CPublishedFileGetDetailsRequest { +mut res := CPublishedFileGetDetailsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.publishedfileids << v +i = ii +} + +2 { +res.has_includetags = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.includetags = v +i = ii +} + +3 { +res.has_includeadditionalpreviews = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.includeadditionalpreviews = v +i = ii +} + +4 { +res.has_includechildren = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.includechildren = v +i = ii +} + +5 { +res.has_includekvtags = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.includekvtags = v +i = ii +} + +6 { +res.has_includevotes = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.includevotes = v +i = ii +} + +8 { +res.has_short_description = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.short_description = v +i = ii +} + +10 { +res.has_includeforsaledata = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.includeforsaledata = v +i = ii +} + +11 { +res.has_includemetadata = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.includemetadata = v +i = ii +} + +12 { +res.has_language = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +13 { +res.has_return_playtime_stats = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.return_playtime_stats = v +i = ii +} + +14 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +15 { +res.has_strip_description_bbcode = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.strip_description_bbcode = v +i = ii +} + +16 { +res.has_desired_revision = true +ii, v := zzz_vproto_internal_unpack_epublishedfilerevision(cur_buf, tag_wiretype.wire_type)? +res.desired_revision = v +i = ii +} + +17 { +res.has_includereactions = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.includereactions = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilegetdetailsrequest() CPublishedFileGetDetailsRequest { +return CPublishedFileGetDetailsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilegetdetailsrequest(o CPublishedFileGetDetailsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilegetdetailsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileGetDetailsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilegetdetailsrequest_unpack(v)? +return i, unpacked +} +pub struct PublishedFileDetailsTag { +mut: +unknown_fields []vproto.UnknownField +pub mut: +tag string +has_tag bool +adminonly bool +has_adminonly bool +} +pub fn (o &PublishedFileDetailsTag) pack() []byte { +mut res := []byte{} +if o.has_tag { +res << vproto.pack_string_field(o.tag, 1) +} + +if o.has_adminonly { +res << vproto.pack_bool_field(o.adminonly, 2) +} + +return res +} + +pub fn publishedfiledetailstag_unpack(buf []byte) ?PublishedFileDetailsTag { +mut res := PublishedFileDetailsTag{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_tag = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.tag = v +i = ii +} + +2 { +res.has_adminonly = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.adminonly = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_publishedfiledetailstag() PublishedFileDetailsTag { +return PublishedFileDetailsTag{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_publishedfiledetailstag(o PublishedFileDetailsTag, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_publishedfiledetailstag(buf []byte, tag_wiretype vproto.WireType) ?(int, PublishedFileDetailsTag) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := publishedfiledetailstag_unpack(v)? +return i, unpacked +} +pub struct PublishedFileDetailsPreview { +mut: +unknown_fields []vproto.UnknownField +pub mut: +previewid u64 +has_previewid bool +sortorder u32 +has_sortorder bool +url string +has_url bool +size u32 +has_size bool +filename string +has_filename bool +youtubevideoid string +has_youtubevideoid bool +preview_type u32 +has_preview_type bool +external_reference string +has_external_reference bool +} +pub fn (o &PublishedFileDetailsPreview) pack() []byte { +mut res := []byte{} +if o.has_previewid { +res << vproto.pack_uint64_field(o.previewid, 1) +} + +if o.has_sortorder { +res << vproto.pack_uint32_field(o.sortorder, 2) +} + +if o.has_url { +res << vproto.pack_string_field(o.url, 3) +} + +if o.has_size { +res << vproto.pack_uint32_field(o.size, 4) +} + +if o.has_filename { +res << vproto.pack_string_field(o.filename, 5) +} + +if o.has_youtubevideoid { +res << vproto.pack_string_field(o.youtubevideoid, 6) +} + +if o.has_preview_type { +res << vproto.pack_uint32_field(o.preview_type, 7) +} + +if o.has_external_reference { +res << vproto.pack_string_field(o.external_reference, 8) +} + +return res +} + +pub fn publishedfiledetailspreview_unpack(buf []byte) ?PublishedFileDetailsPreview { +mut res := PublishedFileDetailsPreview{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_previewid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.previewid = v +i = ii +} + +2 { +res.has_sortorder = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.sortorder = v +i = ii +} + +3 { +res.has_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url = v +i = ii +} + +4 { +res.has_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.size = v +i = ii +} + +5 { +res.has_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.filename = v +i = ii +} + +6 { +res.has_youtubevideoid = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.youtubevideoid = v +i = ii +} + +7 { +res.has_preview_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.preview_type = v +i = ii +} + +8 { +res.has_external_reference = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.external_reference = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_publishedfiledetailspreview() PublishedFileDetailsPreview { +return PublishedFileDetailsPreview{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_publishedfiledetailspreview(o PublishedFileDetailsPreview, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_publishedfiledetailspreview(buf []byte, tag_wiretype vproto.WireType) ?(int, PublishedFileDetailsPreview) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := publishedfiledetailspreview_unpack(v)? +return i, unpacked +} +pub struct PublishedFileDetailsChild { +mut: +unknown_fields []vproto.UnknownField +pub mut: +publishedfileid u64 +has_publishedfileid bool +sortorder u32 +has_sortorder bool +file_type u32 +has_file_type bool +} +pub fn (o &PublishedFileDetailsChild) pack() []byte { +mut res := []byte{} +if o.has_publishedfileid { +res << vproto.pack_uint64_field(o.publishedfileid, 1) +} + +if o.has_sortorder { +res << vproto.pack_uint32_field(o.sortorder, 2) +} + +if o.has_file_type { +res << vproto.pack_uint32_field(o.file_type, 3) +} + +return res +} + +pub fn publishedfiledetailschild_unpack(buf []byte) ?PublishedFileDetailsChild { +mut res := PublishedFileDetailsChild{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_publishedfileid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.publishedfileid = v +i = ii +} + +2 { +res.has_sortorder = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.sortorder = v +i = ii +} + +3 { +res.has_file_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.file_type = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_publishedfiledetailschild() PublishedFileDetailsChild { +return PublishedFileDetailsChild{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_publishedfiledetailschild(o PublishedFileDetailsChild, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_publishedfiledetailschild(buf []byte, tag_wiretype vproto.WireType) ?(int, PublishedFileDetailsChild) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := publishedfiledetailschild_unpack(v)? +return i, unpacked +} +pub struct PublishedFileDetailsKVtag { +mut: +unknown_fields []vproto.UnknownField +pub mut: +key string +has_key bool +value string +has_value bool +} +pub fn (o &PublishedFileDetailsKVtag) pack() []byte { +mut res := []byte{} +if o.has_key { +res << vproto.pack_string_field(o.key, 1) +} + +if o.has_value { +res << vproto.pack_string_field(o.value, 2) +} + +return res +} + +pub fn publishedfiledetailskvtag_unpack(buf []byte) ?PublishedFileDetailsKVtag { +mut res := PublishedFileDetailsKVtag{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_key = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.key = v +i = ii +} + +2 { +res.has_value = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.value = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_publishedfiledetailskvtag() PublishedFileDetailsKVtag { +return PublishedFileDetailsKVtag{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_publishedfiledetailskvtag(o PublishedFileDetailsKVtag, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_publishedfiledetailskvtag(buf []byte, tag_wiretype vproto.WireType) ?(int, PublishedFileDetailsKVtag) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := publishedfiledetailskvtag_unpack(v)? +return i, unpacked +} +pub struct PublishedFileDetailsVoteData { +mut: +unknown_fields []vproto.UnknownField +pub mut: +score f32 +has_score bool +votes_up u32 +has_votes_up bool +votes_down u32 +has_votes_down bool +} +pub fn (o &PublishedFileDetailsVoteData) pack() []byte { +mut res := []byte{} +if o.has_score { +res << vproto.pack_float_field(o.score, 1) +} + +if o.has_votes_up { +res << vproto.pack_uint32_field(o.votes_up, 2) +} + +if o.has_votes_down { +res << vproto.pack_uint32_field(o.votes_down, 3) +} + +return res +} + +pub fn publishedfiledetailsvotedata_unpack(buf []byte) ?PublishedFileDetailsVoteData { +mut res := PublishedFileDetailsVoteData{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_score = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.score = v +i = ii +} + +2 { +res.has_votes_up = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.votes_up = v +i = ii +} + +3 { +res.has_votes_down = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.votes_down = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_publishedfiledetailsvotedata() PublishedFileDetailsVoteData { +return PublishedFileDetailsVoteData{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_publishedfiledetailsvotedata(o PublishedFileDetailsVoteData, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_publishedfiledetailsvotedata(buf []byte, tag_wiretype vproto.WireType) ?(int, PublishedFileDetailsVoteData) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := publishedfiledetailsvotedata_unpack(v)? +return i, unpacked +} +pub struct PublishedFileDetailsForSaleData { +mut: +unknown_fields []vproto.UnknownField +pub mut: +is_for_sale bool +has_is_for_sale bool +price_category u32 +has_price_category bool +estatus EPublishedFileForSaleStatus +has_estatus bool +price_category_floor u32 +has_price_category_floor bool +price_is_pay_what_you_want bool +has_price_is_pay_what_you_want bool +discount_percentage u32 +has_discount_percentage bool +} +pub fn (o &PublishedFileDetailsForSaleData) pack() []byte { +mut res := []byte{} +if o.has_is_for_sale { +res << vproto.pack_bool_field(o.is_for_sale, 1) +} + +if o.has_price_category { +res << vproto.pack_uint32_field(o.price_category, 2) +} + +if o.has_estatus { +res << zzz_vproto_internal_pack_epublishedfileforsalestatus(o.estatus, 3) +} + +if o.has_price_category_floor { +res << vproto.pack_uint32_field(o.price_category_floor, 4) +} + +if o.has_price_is_pay_what_you_want { +res << vproto.pack_bool_field(o.price_is_pay_what_you_want, 5) +} + +if o.has_discount_percentage { +res << vproto.pack_uint32_field(o.discount_percentage, 6) +} + +return res +} + +pub fn publishedfiledetailsforsaledata_unpack(buf []byte) ?PublishedFileDetailsForSaleData { +mut res := PublishedFileDetailsForSaleData{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_is_for_sale = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_for_sale = v +i = ii +} + +2 { +res.has_price_category = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.price_category = v +i = ii +} + +3 { +res.has_estatus = true +ii, v := zzz_vproto_internal_unpack_epublishedfileforsalestatus(cur_buf, tag_wiretype.wire_type)? +res.estatus = v +i = ii +} + +4 { +res.has_price_category_floor = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.price_category_floor = v +i = ii +} + +5 { +res.has_price_is_pay_what_you_want = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.price_is_pay_what_you_want = v +i = ii +} + +6 { +res.has_discount_percentage = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.discount_percentage = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_publishedfiledetailsforsaledata() PublishedFileDetailsForSaleData { +return PublishedFileDetailsForSaleData{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_publishedfiledetailsforsaledata(o PublishedFileDetailsForSaleData, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_publishedfiledetailsforsaledata(buf []byte, tag_wiretype vproto.WireType) ?(int, PublishedFileDetailsForSaleData) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := publishedfiledetailsforsaledata_unpack(v)? +return i, unpacked +} +pub struct PublishedFileDetailsPlaytimeStats { +mut: +unknown_fields []vproto.UnknownField +pub mut: +playtime_seconds u64 +has_playtime_seconds bool +num_sessions u64 +has_num_sessions bool +} +pub fn (o &PublishedFileDetailsPlaytimeStats) pack() []byte { +mut res := []byte{} +if o.has_playtime_seconds { +res << vproto.pack_uint64_field(o.playtime_seconds, 1) +} + +if o.has_num_sessions { +res << vproto.pack_uint64_field(o.num_sessions, 2) +} + +return res +} + +pub fn publishedfiledetailsplaytimestats_unpack(buf []byte) ?PublishedFileDetailsPlaytimeStats { +mut res := PublishedFileDetailsPlaytimeStats{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_playtime_seconds = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.playtime_seconds = v +i = ii +} + +2 { +res.has_num_sessions = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.num_sessions = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_publishedfiledetailsplaytimestats() PublishedFileDetailsPlaytimeStats { +return PublishedFileDetailsPlaytimeStats{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_publishedfiledetailsplaytimestats(o PublishedFileDetailsPlaytimeStats, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_publishedfiledetailsplaytimestats(buf []byte, tag_wiretype vproto.WireType) ?(int, PublishedFileDetailsPlaytimeStats) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := publishedfiledetailsplaytimestats_unpack(v)? +return i, unpacked +} +pub struct PublishedFileDetailsReaction { +mut: +unknown_fields []vproto.UnknownField +pub mut: +reactionid u32 +has_reactionid bool +count u32 +has_count bool +} +pub fn (o &PublishedFileDetailsReaction) pack() []byte { +mut res := []byte{} +if o.has_reactionid { +res << vproto.pack_uint32_field(o.reactionid, 1) +} + +if o.has_count { +res << vproto.pack_uint32_field(o.count, 2) +} + +return res +} + +pub fn publishedfiledetailsreaction_unpack(buf []byte) ?PublishedFileDetailsReaction { +mut res := PublishedFileDetailsReaction{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_reactionid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.reactionid = v +i = ii +} + +2 { +res.has_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.count = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_publishedfiledetailsreaction() PublishedFileDetailsReaction { +return PublishedFileDetailsReaction{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_publishedfiledetailsreaction(o PublishedFileDetailsReaction, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_publishedfiledetailsreaction(buf []byte, tag_wiretype vproto.WireType) ?(int, PublishedFileDetailsReaction) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := publishedfiledetailsreaction_unpack(v)? +return i, unpacked +} +pub struct PublishedFileDetails { +mut: +unknown_fields []vproto.UnknownField +pub mut: +result u32 +has_result bool +publishedfileid u64 +has_publishedfileid bool +creator u64 +has_creator bool +creator_appid u32 +has_creator_appid bool +consumer_appid u32 +has_consumer_appid bool +consumer_shortcutid u32 +has_consumer_shortcutid bool +filename string +has_filename bool +file_size u64 +has_file_size bool +preview_file_size u64 +has_preview_file_size bool +file_url string +has_file_url bool +preview_url string +has_preview_url bool +youtubevideoid string +has_youtubevideoid bool +url string +has_url bool +hcontent_file u64 +has_hcontent_file bool +hcontent_preview u64 +has_hcontent_preview bool +title string +has_title bool +file_description string +has_file_description bool +short_description string +has_short_description bool +time_created u32 +has_time_created bool +time_updated u32 +has_time_updated bool +visibility u32 +has_visibility bool +flags u32 +has_flags bool +workshop_file bool +has_workshop_file bool +workshop_accepted bool +has_workshop_accepted bool +show_subscribe_all bool +has_show_subscribe_all bool +num_comments_developer int +has_num_comments_developer bool +num_comments_public int +has_num_comments_public bool +banned bool +has_banned bool +ban_reason string +has_ban_reason bool +banner u64 +has_banner bool +can_be_deleted bool +has_can_be_deleted bool +incompatible bool +has_incompatible bool +app_name string +has_app_name bool +file_type u32 +has_file_type bool +can_subscribe bool +has_can_subscribe bool +subscriptions u32 +has_subscriptions bool +favorited u32 +has_favorited bool +followers u32 +has_followers bool +lifetime_subscriptions u32 +has_lifetime_subscriptions bool +lifetime_favorited u32 +has_lifetime_favorited bool +lifetime_followers u32 +has_lifetime_followers bool +lifetime_playtime u64 +has_lifetime_playtime bool +lifetime_playtime_sessions u64 +has_lifetime_playtime_sessions bool +views u32 +has_views bool +image_width u32 +has_image_width bool +image_height u32 +has_image_height bool +image_url string +has_image_url bool +spoiler_tag bool +has_spoiler_tag bool +shortcutid u32 +has_shortcutid bool +shortcutname string +has_shortcutname bool +num_children u32 +has_num_children bool +num_reports u32 +has_num_reports bool +previews []PublishedFileDetailsPreview +tags []PublishedFileDetailsTag +children []PublishedFileDetailsChild +kvtags []PublishedFileDetailsKVtag +vote_data PublishedFileDetailsVoteData +has_vote_data bool +playtime_stats PublishedFileDetailsPlaytimeStats +has_playtime_stats bool +time_subscribed u32 +has_time_subscribed bool +for_sale_data PublishedFileDetailsForSaleData +has_for_sale_data bool +metadata string +has_metadata bool +language int +has_language bool +maybe_inappropriate_sex bool +has_maybe_inappropriate_sex bool +maybe_inappropriate_violence bool +has_maybe_inappropriate_violence bool +revision_change_number u64 +has_revision_change_number bool +revision EPublishedFileRevision +has_revision bool +available_revisions []EPublishedFileRevision +reactions []PublishedFileDetailsReaction +} +pub fn (o &PublishedFileDetails) pack() []byte { +mut res := []byte{} +if o.has_result { +res << vproto.pack_uint32_field(o.result, 1) +} + +if o.has_publishedfileid { +res << vproto.pack_uint64_field(o.publishedfileid, 2) +} + +if o.has_creator { +res << vproto.pack_64bit_field(o.creator, 3) +} + +if o.has_creator_appid { +res << vproto.pack_uint32_field(o.creator_appid, 4) +} + +if o.has_consumer_appid { +res << vproto.pack_uint32_field(o.consumer_appid, 5) +} + +if o.has_consumer_shortcutid { +res << vproto.pack_uint32_field(o.consumer_shortcutid, 6) +} + +if o.has_filename { +res << vproto.pack_string_field(o.filename, 7) +} + +if o.has_file_size { +res << vproto.pack_uint64_field(o.file_size, 8) +} + +if o.has_preview_file_size { +res << vproto.pack_uint64_field(o.preview_file_size, 9) +} + +if o.has_file_url { +res << vproto.pack_string_field(o.file_url, 10) +} + +if o.has_preview_url { +res << vproto.pack_string_field(o.preview_url, 11) +} + +if o.has_youtubevideoid { +res << vproto.pack_string_field(o.youtubevideoid, 12) +} + +if o.has_url { +res << vproto.pack_string_field(o.url, 13) +} + +if o.has_hcontent_file { +res << vproto.pack_64bit_field(o.hcontent_file, 14) +} + +if o.has_hcontent_preview { +res << vproto.pack_64bit_field(o.hcontent_preview, 15) +} + +if o.has_title { +res << vproto.pack_string_field(o.title, 16) +} + +if o.has_file_description { +res << vproto.pack_string_field(o.file_description, 17) +} + +if o.has_short_description { +res << vproto.pack_string_field(o.short_description, 18) +} + +if o.has_time_created { +res << vproto.pack_uint32_field(o.time_created, 19) +} + +if o.has_time_updated { +res << vproto.pack_uint32_field(o.time_updated, 20) +} + +if o.has_visibility { +res << vproto.pack_uint32_field(o.visibility, 21) +} + +if o.has_flags { +res << vproto.pack_uint32_field(o.flags, 22) +} + +if o.has_workshop_file { +res << vproto.pack_bool_field(o.workshop_file, 23) +} + +if o.has_workshop_accepted { +res << vproto.pack_bool_field(o.workshop_accepted, 24) +} + +if o.has_show_subscribe_all { +res << vproto.pack_bool_field(o.show_subscribe_all, 25) +} + +if o.has_num_comments_developer { +res << vproto.pack_int32_field(o.num_comments_developer, 26) +} + +if o.has_num_comments_public { +res << vproto.pack_int32_field(o.num_comments_public, 27) +} + +if o.has_banned { +res << vproto.pack_bool_field(o.banned, 28) +} + +if o.has_ban_reason { +res << vproto.pack_string_field(o.ban_reason, 29) +} + +if o.has_banner { +res << vproto.pack_64bit_field(o.banner, 30) +} + +if o.has_can_be_deleted { +res << vproto.pack_bool_field(o.can_be_deleted, 31) +} + +if o.has_incompatible { +res << vproto.pack_bool_field(o.incompatible, 32) +} + +if o.has_app_name { +res << vproto.pack_string_field(o.app_name, 33) +} + +if o.has_file_type { +res << vproto.pack_uint32_field(o.file_type, 34) +} + +if o.has_can_subscribe { +res << vproto.pack_bool_field(o.can_subscribe, 35) +} + +if o.has_subscriptions { +res << vproto.pack_uint32_field(o.subscriptions, 36) +} + +if o.has_favorited { +res << vproto.pack_uint32_field(o.favorited, 37) +} + +if o.has_followers { +res << vproto.pack_uint32_field(o.followers, 38) +} + +if o.has_lifetime_subscriptions { +res << vproto.pack_uint32_field(o.lifetime_subscriptions, 39) +} + +if o.has_lifetime_favorited { +res << vproto.pack_uint32_field(o.lifetime_favorited, 40) +} + +if o.has_lifetime_followers { +res << vproto.pack_uint32_field(o.lifetime_followers, 41) +} + +if o.has_lifetime_playtime { +res << vproto.pack_uint64_field(o.lifetime_playtime, 62) +} + +if o.has_lifetime_playtime_sessions { +res << vproto.pack_uint64_field(o.lifetime_playtime_sessions, 63) +} + +if o.has_views { +res << vproto.pack_uint32_field(o.views, 42) +} + +if o.has_image_width { +res << vproto.pack_uint32_field(o.image_width, 43) +} + +if o.has_image_height { +res << vproto.pack_uint32_field(o.image_height, 44) +} + +if o.has_image_url { +res << vproto.pack_string_field(o.image_url, 45) +} + +if o.has_spoiler_tag { +res << vproto.pack_bool_field(o.spoiler_tag, 46) +} + +if o.has_shortcutid { +res << vproto.pack_uint32_field(o.shortcutid, 47) +} + +if o.has_shortcutname { +res << vproto.pack_string_field(o.shortcutname, 48) +} + +if o.has_num_children { +res << vproto.pack_uint32_field(o.num_children, 49) +} + +if o.has_num_reports { +res << vproto.pack_uint32_field(o.num_reports, 50) +} + +// [packed=false] +for _, x in o.previews { +res << zzz_vproto_internal_pack_publishedfiledetailspreview(x, 51) +} + +// [packed=false] +for _, x in o.tags { +res << zzz_vproto_internal_pack_publishedfiledetailstag(x, 52) +} + +// [packed=false] +for _, x in o.children { +res << zzz_vproto_internal_pack_publishedfiledetailschild(x, 53) +} + +// [packed=false] +for _, x in o.kvtags { +res << zzz_vproto_internal_pack_publishedfiledetailskvtag(x, 54) +} + +if o.has_vote_data { +res << zzz_vproto_internal_pack_publishedfiledetailsvotedata(o.vote_data, 55) +} + +if o.has_playtime_stats { +res << zzz_vproto_internal_pack_publishedfiledetailsplaytimestats(o.playtime_stats, 64) +} + +if o.has_time_subscribed { +res << vproto.pack_uint32_field(o.time_subscribed, 56) +} + +if o.has_for_sale_data { +res << zzz_vproto_internal_pack_publishedfiledetailsforsaledata(o.for_sale_data, 57) +} + +if o.has_metadata { +res << vproto.pack_string_field(o.metadata, 58) +} + +if o.has_language { +res << vproto.pack_int32_field(o.language, 61) +} + +if o.has_maybe_inappropriate_sex { +res << vproto.pack_bool_field(o.maybe_inappropriate_sex, 65) +} + +if o.has_maybe_inappropriate_violence { +res << vproto.pack_bool_field(o.maybe_inappropriate_violence, 66) +} + +if o.has_revision_change_number { +res << vproto.pack_uint64_field(o.revision_change_number, 67) +} + +if o.has_revision { +res << zzz_vproto_internal_pack_epublishedfilerevision(o.revision, 68) +} + +// [packed=false] +for _, x in o.available_revisions { +res << zzz_vproto_internal_pack_epublishedfilerevision(x, 69) +} + +// [packed=false] +for _, x in o.reactions { +res << zzz_vproto_internal_pack_publishedfiledetailsreaction(x, 70) +} + +return res +} + +pub fn publishedfiledetails_unpack(buf []byte) ?PublishedFileDetails { +mut res := PublishedFileDetails{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_result = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.result = v +i = ii +} + +2 { +res.has_publishedfileid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.publishedfileid = v +i = ii +} + +3 { +res.has_creator = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.creator = v +i = ii +} + +4 { +res.has_creator_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.creator_appid = v +i = ii +} + +5 { +res.has_consumer_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.consumer_appid = v +i = ii +} + +6 { +res.has_consumer_shortcutid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.consumer_shortcutid = v +i = ii +} + +7 { +res.has_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.filename = v +i = ii +} + +8 { +res.has_file_size = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.file_size = v +i = ii +} + +9 { +res.has_preview_file_size = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.preview_file_size = v +i = ii +} + +10 { +res.has_file_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.file_url = v +i = ii +} + +11 { +res.has_preview_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.preview_url = v +i = ii +} + +12 { +res.has_youtubevideoid = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.youtubevideoid = v +i = ii +} + +13 { +res.has_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.url = v +i = ii +} + +14 { +res.has_hcontent_file = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.hcontent_file = v +i = ii +} + +15 { +res.has_hcontent_preview = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.hcontent_preview = v +i = ii +} + +16 { +res.has_title = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.title = v +i = ii +} + +17 { +res.has_file_description = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.file_description = v +i = ii +} + +18 { +res.has_short_description = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.short_description = v +i = ii +} + +19 { +res.has_time_created = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_created = v +i = ii +} + +20 { +res.has_time_updated = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_updated = v +i = ii +} + +21 { +res.has_visibility = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.visibility = v +i = ii +} + +22 { +res.has_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.flags = v +i = ii +} + +23 { +res.has_workshop_file = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.workshop_file = v +i = ii +} + +24 { +res.has_workshop_accepted = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.workshop_accepted = v +i = ii +} + +25 { +res.has_show_subscribe_all = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.show_subscribe_all = v +i = ii +} + +26 { +res.has_num_comments_developer = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.num_comments_developer = v +i = ii +} + +27 { +res.has_num_comments_public = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.num_comments_public = v +i = ii +} + +28 { +res.has_banned = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.banned = v +i = ii +} + +29 { +res.has_ban_reason = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.ban_reason = v +i = ii +} + +30 { +res.has_banner = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.banner = v +i = ii +} + +31 { +res.has_can_be_deleted = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.can_be_deleted = v +i = ii +} + +32 { +res.has_incompatible = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.incompatible = v +i = ii +} + +33 { +res.has_app_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.app_name = v +i = ii +} + +34 { +res.has_file_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.file_type = v +i = ii +} + +35 { +res.has_can_subscribe = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.can_subscribe = v +i = ii +} + +36 { +res.has_subscriptions = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.subscriptions = v +i = ii +} + +37 { +res.has_favorited = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.favorited = v +i = ii +} + +38 { +res.has_followers = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.followers = v +i = ii +} + +39 { +res.has_lifetime_subscriptions = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.lifetime_subscriptions = v +i = ii +} + +40 { +res.has_lifetime_favorited = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.lifetime_favorited = v +i = ii +} + +41 { +res.has_lifetime_followers = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.lifetime_followers = v +i = ii +} + +62 { +res.has_lifetime_playtime = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.lifetime_playtime = v +i = ii +} + +63 { +res.has_lifetime_playtime_sessions = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.lifetime_playtime_sessions = v +i = ii +} + +42 { +res.has_views = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.views = v +i = ii +} + +43 { +res.has_image_width = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.image_width = v +i = ii +} + +44 { +res.has_image_height = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.image_height = v +i = ii +} + +45 { +res.has_image_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.image_url = v +i = ii +} + +46 { +res.has_spoiler_tag = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.spoiler_tag = v +i = ii +} + +47 { +res.has_shortcutid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.shortcutid = v +i = ii +} + +48 { +res.has_shortcutname = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.shortcutname = v +i = ii +} + +49 { +res.has_num_children = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.num_children = v +i = ii +} + +50 { +res.has_num_reports = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.num_reports = v +i = ii +} + +51 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_publishedfiledetailspreview(cur_buf, tag_wiretype.wire_type)? +res.previews << v +i = ii +} + +52 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_publishedfiledetailstag(cur_buf, tag_wiretype.wire_type)? +res.tags << v +i = ii +} + +53 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_publishedfiledetailschild(cur_buf, tag_wiretype.wire_type)? +res.children << v +i = ii +} + +54 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_publishedfiledetailskvtag(cur_buf, tag_wiretype.wire_type)? +res.kvtags << v +i = ii +} + +55 { +res.has_vote_data = true +ii, v := zzz_vproto_internal_unpack_publishedfiledetailsvotedata(cur_buf, tag_wiretype.wire_type)? +res.vote_data = v +i = ii +} + +64 { +res.has_playtime_stats = true +ii, v := zzz_vproto_internal_unpack_publishedfiledetailsplaytimestats(cur_buf, tag_wiretype.wire_type)? +res.playtime_stats = v +i = ii +} + +56 { +res.has_time_subscribed = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_subscribed = v +i = ii +} + +57 { +res.has_for_sale_data = true +ii, v := zzz_vproto_internal_unpack_publishedfiledetailsforsaledata(cur_buf, tag_wiretype.wire_type)? +res.for_sale_data = v +i = ii +} + +58 { +res.has_metadata = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.metadata = v +i = ii +} + +61 { +res.has_language = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +65 { +res.has_maybe_inappropriate_sex = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.maybe_inappropriate_sex = v +i = ii +} + +66 { +res.has_maybe_inappropriate_violence = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.maybe_inappropriate_violence = v +i = ii +} + +67 { +res.has_revision_change_number = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.revision_change_number = v +i = ii +} + +68 { +res.has_revision = true +ii, v := zzz_vproto_internal_unpack_epublishedfilerevision(cur_buf, tag_wiretype.wire_type)? +res.revision = v +i = ii +} + +69 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_epublishedfilerevision(cur_buf, tag_wiretype.wire_type)? +res.available_revisions << v +i = ii +} + +70 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_publishedfiledetailsreaction(cur_buf, tag_wiretype.wire_type)? +res.reactions << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_publishedfiledetails() PublishedFileDetails { +return PublishedFileDetails{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_publishedfiledetails(o PublishedFileDetails, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_publishedfiledetails(buf []byte, tag_wiretype vproto.WireType) ?(int, PublishedFileDetails) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := publishedfiledetails_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileGetDetailsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +publishedfiledetails []PublishedFileDetails +} +pub fn (o &CPublishedFileGetDetailsResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.publishedfiledetails { +res << zzz_vproto_internal_pack_publishedfiledetails(x, 1) +} + +return res +} + +pub fn cpublishedfilegetdetailsresponse_unpack(buf []byte) ?CPublishedFileGetDetailsResponse { +mut res := CPublishedFileGetDetailsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_publishedfiledetails(cur_buf, tag_wiretype.wire_type)? +res.publishedfiledetails << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilegetdetailsresponse() CPublishedFileGetDetailsResponse { +return CPublishedFileGetDetailsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilegetdetailsresponse(o CPublishedFileGetDetailsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilegetdetailsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileGetDetailsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilegetdetailsresponse_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileGetItemInfoRequestWorkshopItem { +mut: +unknown_fields []vproto.UnknownField +pub mut: +published_file_id u64 +has_published_file_id bool +time_updated u32 +has_time_updated bool +desired_revision EPublishedFileRevision +has_desired_revision bool +} +pub fn (o &CPublishedFileGetItemInfoRequestWorkshopItem) pack() []byte { +mut res := []byte{} +if o.has_published_file_id { +res << vproto.pack_64bit_field(o.published_file_id, 1) +} + +if o.has_time_updated { +res << vproto.pack_uint32_field(o.time_updated, 2) +} + +if o.has_desired_revision { +res << zzz_vproto_internal_pack_epublishedfilerevision(o.desired_revision, 3) +} + +return res +} + +pub fn cpublishedfilegetiteminforequestworkshopitem_unpack(buf []byte) ?CPublishedFileGetItemInfoRequestWorkshopItem { +mut res := CPublishedFileGetItemInfoRequestWorkshopItem{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_published_file_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.published_file_id = v +i = ii +} + +2 { +res.has_time_updated = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_updated = v +i = ii +} + +3 { +res.has_desired_revision = true +ii, v := zzz_vproto_internal_unpack_epublishedfilerevision(cur_buf, tag_wiretype.wire_type)? +res.desired_revision = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilegetiteminforequestworkshopitem() CPublishedFileGetItemInfoRequestWorkshopItem { +return CPublishedFileGetItemInfoRequestWorkshopItem{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilegetiteminforequestworkshopitem(o CPublishedFileGetItemInfoRequestWorkshopItem, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilegetiteminforequestworkshopitem(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileGetItemInfoRequestWorkshopItem) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilegetiteminforequestworkshopitem_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileGetItemInfoRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +last_time_updated u32 +has_last_time_updated bool +workshop_items []CPublishedFileGetItemInfoRequestWorkshopItem +} +pub fn (o &CPublishedFileGetItemInfoRequest) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_last_time_updated { +res << vproto.pack_uint32_field(o.last_time_updated, 2) +} + +// [packed=false] +for _, x in o.workshop_items { +res << zzz_vproto_internal_pack_cpublishedfilegetiteminforequestworkshopitem(x, 3) +} + +return res +} + +pub fn cpublishedfilegetiteminforequest_unpack(buf []byte) ?CPublishedFileGetItemInfoRequest { +mut res := CPublishedFileGetItemInfoRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_last_time_updated = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_time_updated = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cpublishedfilegetiteminforequestworkshopitem(cur_buf, tag_wiretype.wire_type)? +res.workshop_items << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilegetiteminforequest() CPublishedFileGetItemInfoRequest { +return CPublishedFileGetItemInfoRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilegetiteminforequest(o CPublishedFileGetItemInfoRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilegetiteminforequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileGetItemInfoRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilegetiteminforequest_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileGetItemInfoResponseWorkshopItemInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +published_file_id u64 +has_published_file_id bool +time_updated u32 +has_time_updated bool +manifest_id u64 +has_manifest_id bool +flags u32 +has_flags bool +} +pub fn (o &CPublishedFileGetItemInfoResponseWorkshopItemInfo) pack() []byte { +mut res := []byte{} +if o.has_published_file_id { +res << vproto.pack_64bit_field(o.published_file_id, 1) +} + +if o.has_time_updated { +res << vproto.pack_uint32_field(o.time_updated, 2) +} + +if o.has_manifest_id { +res << vproto.pack_64bit_field(o.manifest_id, 3) +} + +if o.has_flags { +res << vproto.pack_uint32_field(o.flags, 4) +} + +return res +} + +pub fn cpublishedfilegetiteminforesponseworkshopiteminfo_unpack(buf []byte) ?CPublishedFileGetItemInfoResponseWorkshopItemInfo { +mut res := CPublishedFileGetItemInfoResponseWorkshopItemInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_published_file_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.published_file_id = v +i = ii +} + +2 { +res.has_time_updated = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_updated = v +i = ii +} + +3 { +res.has_manifest_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.manifest_id = v +i = ii +} + +4 { +res.has_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.flags = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilegetiteminforesponseworkshopiteminfo() CPublishedFileGetItemInfoResponseWorkshopItemInfo { +return CPublishedFileGetItemInfoResponseWorkshopItemInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilegetiteminforesponseworkshopiteminfo(o CPublishedFileGetItemInfoResponseWorkshopItemInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilegetiteminforesponseworkshopiteminfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileGetItemInfoResponseWorkshopItemInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilegetiteminforesponseworkshopiteminfo_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileGetItemInfoResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +update_time u32 +has_update_time bool +workshop_items []CPublishedFileGetItemInfoResponseWorkshopItemInfo +private_items []u64 +} +pub fn (o &CPublishedFileGetItemInfoResponse) pack() []byte { +mut res := []byte{} +if o.has_update_time { +res << vproto.pack_uint32_field(o.update_time, 1) +} + +// [packed=false] +for _, x in o.workshop_items { +res << zzz_vproto_internal_pack_cpublishedfilegetiteminforesponseworkshopiteminfo(x, 2) +} + +// [packed=false] +for _, x in o.private_items { +res << vproto.pack_64bit_field(x, 3) +} + +return res +} + +pub fn cpublishedfilegetiteminforesponse_unpack(buf []byte) ?CPublishedFileGetItemInfoResponse { +mut res := CPublishedFileGetItemInfoResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_update_time = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.update_time = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cpublishedfilegetiteminforesponseworkshopiteminfo(cur_buf, tag_wiretype.wire_type)? +res.workshop_items << v +i = ii +} + +3 { +// [packed=false] +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.private_items << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilegetiteminforesponse() CPublishedFileGetItemInfoResponse { +return CPublishedFileGetItemInfoResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilegetiteminforesponse(o CPublishedFileGetItemInfoResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilegetiteminforesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileGetItemInfoResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilegetiteminforesponse_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileGetUserFilesRequestKVtag { +mut: +unknown_fields []vproto.UnknownField +pub mut: +key string +has_key bool +value string +has_value bool +} +pub fn (o &CPublishedFileGetUserFilesRequestKVtag) pack() []byte { +mut res := []byte{} +if o.has_key { +res << vproto.pack_string_field(o.key, 1) +} + +if o.has_value { +res << vproto.pack_string_field(o.value, 2) +} + +return res +} + +pub fn cpublishedfilegetuserfilesrequestkvtag_unpack(buf []byte) ?CPublishedFileGetUserFilesRequestKVtag { +mut res := CPublishedFileGetUserFilesRequestKVtag{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_key = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.key = v +i = ii +} + +2 { +res.has_value = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.value = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilegetuserfilesrequestkvtag() CPublishedFileGetUserFilesRequestKVtag { +return CPublishedFileGetUserFilesRequestKVtag{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilegetuserfilesrequestkvtag(o CPublishedFileGetUserFilesRequestKVtag, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilegetuserfilesrequestkvtag(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileGetUserFilesRequestKVtag) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilegetuserfilesrequestkvtag_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileGetUserFilesRequestTagGroup { +mut: +unknown_fields []vproto.UnknownField +pub mut: +tags []string +} +pub fn (o &CPublishedFileGetUserFilesRequestTagGroup) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.tags { +res << vproto.pack_string_field(x, 1) +} + +return res +} + +pub fn cpublishedfilegetuserfilesrequesttaggroup_unpack(buf []byte) ?CPublishedFileGetUserFilesRequestTagGroup { +mut res := CPublishedFileGetUserFilesRequestTagGroup{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.tags << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilegetuserfilesrequesttaggroup() CPublishedFileGetUserFilesRequestTagGroup { +return CPublishedFileGetUserFilesRequestTagGroup{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilegetuserfilesrequesttaggroup(o CPublishedFileGetUserFilesRequestTagGroup, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilegetuserfilesrequesttaggroup(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileGetUserFilesRequestTagGroup) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilegetuserfilesrequesttaggroup_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileGetUserFilesRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +appid u32 +has_appid bool +page u32 +has_page bool +numperpage u32 +has_numperpage bool +@type string +has_type bool +sortmethod string +has_sortmethod bool +privacy u32 +has_privacy bool +requiredtags []string +excludedtags []string +required_kv_tags []CPublishedFileGetUserFilesRequestKVtag +filetype u32 +has_filetype bool +creator_appid u32 +has_creator_appid bool +match_cloud_filename string +has_match_cloud_filename bool +cache_max_age_seconds u32 +has_cache_max_age_seconds bool +language int +has_language bool +taggroups []CPublishedFileGetUserFilesRequestTagGroup +totalonly bool +has_totalonly bool +ids_only bool +has_ids_only bool +return_vote_data bool +has_return_vote_data bool +return_tags bool +has_return_tags bool +return_kv_tags bool +has_return_kv_tags bool +return_previews bool +has_return_previews bool +return_children bool +has_return_children bool +return_short_description bool +has_return_short_description bool +return_for_sale_data bool +has_return_for_sale_data bool +return_metadata bool +has_return_metadata bool +return_playtime_stats u32 +has_return_playtime_stats bool +strip_description_bbcode bool +has_strip_description_bbcode bool +return_reactions bool +has_return_reactions bool +desired_revision EPublishedFileRevision +has_desired_revision bool +} +pub fn (o &CPublishedFileGetUserFilesRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 2) +} + +if o.has_page { +res << vproto.pack_uint32_field(o.page, 4) +} + +if o.has_numperpage { +res << vproto.pack_uint32_field(o.numperpage, 5) +} + +if o.has_type { +res << vproto.pack_string_field(o.@type, 6) +} + +if o.has_sortmethod { +res << vproto.pack_string_field(o.sortmethod, 7) +} + +if o.has_privacy { +res << vproto.pack_uint32_field(o.privacy, 9) +} + +// [packed=false] +for _, x in o.requiredtags { +res << vproto.pack_string_field(x, 10) +} + +// [packed=false] +for _, x in o.excludedtags { +res << vproto.pack_string_field(x, 11) +} + +// [packed=false] +for _, x in o.required_kv_tags { +res << zzz_vproto_internal_pack_cpublishedfilegetuserfilesrequestkvtag(x, 30) +} + +if o.has_filetype { +res << vproto.pack_uint32_field(o.filetype, 14) +} + +if o.has_creator_appid { +res << vproto.pack_uint32_field(o.creator_appid, 15) +} + +if o.has_match_cloud_filename { +res << vproto.pack_string_field(o.match_cloud_filename, 16) +} + +if o.has_cache_max_age_seconds { +res << vproto.pack_uint32_field(o.cache_max_age_seconds, 27) +} + +if o.has_language { +res << vproto.pack_int32_field(o.language, 29) +} + +// [packed=false] +for _, x in o.taggroups { +res << zzz_vproto_internal_pack_cpublishedfilegetuserfilesrequesttaggroup(x, 34) +} + +if o.has_totalonly { +res << vproto.pack_bool_field(o.totalonly, 17) +} + +if o.has_ids_only { +res << vproto.pack_bool_field(o.ids_only, 18) +} + +if o.has_return_vote_data { +res << vproto.pack_bool_field(o.return_vote_data, 19) +} + +if o.has_return_tags { +res << vproto.pack_bool_field(o.return_tags, 20) +} + +if o.has_return_kv_tags { +res << vproto.pack_bool_field(o.return_kv_tags, 21) +} + +if o.has_return_previews { +res << vproto.pack_bool_field(o.return_previews, 22) +} + +if o.has_return_children { +res << vproto.pack_bool_field(o.return_children, 23) +} + +if o.has_return_short_description { +res << vproto.pack_bool_field(o.return_short_description, 24) +} + +if o.has_return_for_sale_data { +res << vproto.pack_bool_field(o.return_for_sale_data, 26) +} + +if o.has_return_metadata { +res << vproto.pack_bool_field(o.return_metadata, 28) +} + +if o.has_return_playtime_stats { +res << vproto.pack_uint32_field(o.return_playtime_stats, 31) +} + +if o.has_strip_description_bbcode { +res << vproto.pack_bool_field(o.strip_description_bbcode, 32) +} + +if o.has_return_reactions { +res << vproto.pack_bool_field(o.return_reactions, 35) +} + +if o.has_desired_revision { +res << zzz_vproto_internal_pack_epublishedfilerevision(o.desired_revision, 33) +} + +return res +} + +pub fn cpublishedfilegetuserfilesrequest_unpack(buf []byte) ?CPublishedFileGetUserFilesRequest { +mut res := CPublishedFileGetUserFilesRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +4 { +res.has_page = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.page = v +i = ii +} + +5 { +res.has_numperpage = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.numperpage = v +i = ii +} + +6 { +res.has_type = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.@type = v +i = ii +} + +7 { +res.has_sortmethod = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.sortmethod = v +i = ii +} + +9 { +res.has_privacy = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.privacy = v +i = ii +} + +10 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.requiredtags << v +i = ii +} + +11 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.excludedtags << v +i = ii +} + +30 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cpublishedfilegetuserfilesrequestkvtag(cur_buf, tag_wiretype.wire_type)? +res.required_kv_tags << v +i = ii +} + +14 { +res.has_filetype = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.filetype = v +i = ii +} + +15 { +res.has_creator_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.creator_appid = v +i = ii +} + +16 { +res.has_match_cloud_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.match_cloud_filename = v +i = ii +} + +27 { +res.has_cache_max_age_seconds = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cache_max_age_seconds = v +i = ii +} + +29 { +res.has_language = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +34 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cpublishedfilegetuserfilesrequesttaggroup(cur_buf, tag_wiretype.wire_type)? +res.taggroups << v +i = ii +} + +17 { +res.has_totalonly = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.totalonly = v +i = ii +} + +18 { +res.has_ids_only = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.ids_only = v +i = ii +} + +19 { +res.has_return_vote_data = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.return_vote_data = v +i = ii +} + +20 { +res.has_return_tags = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.return_tags = v +i = ii +} + +21 { +res.has_return_kv_tags = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.return_kv_tags = v +i = ii +} + +22 { +res.has_return_previews = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.return_previews = v +i = ii +} + +23 { +res.has_return_children = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.return_children = v +i = ii +} + +24 { +res.has_return_short_description = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.return_short_description = v +i = ii +} + +26 { +res.has_return_for_sale_data = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.return_for_sale_data = v +i = ii +} + +28 { +res.has_return_metadata = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.return_metadata = v +i = ii +} + +31 { +res.has_return_playtime_stats = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.return_playtime_stats = v +i = ii +} + +32 { +res.has_strip_description_bbcode = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.strip_description_bbcode = v +i = ii +} + +35 { +res.has_return_reactions = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.return_reactions = v +i = ii +} + +33 { +res.has_desired_revision = true +ii, v := zzz_vproto_internal_unpack_epublishedfilerevision(cur_buf, tag_wiretype.wire_type)? +res.desired_revision = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilegetuserfilesrequest() CPublishedFileGetUserFilesRequest { +return CPublishedFileGetUserFilesRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilegetuserfilesrequest(o CPublishedFileGetUserFilesRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilegetuserfilesrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileGetUserFilesRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilegetuserfilesrequest_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileGetUserFilesResponseApp { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +name string +has_name bool +shortcutid u32 +has_shortcutid bool +private bool +has_private bool +} +pub fn (o &CPublishedFileGetUserFilesResponseApp) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_name { +res << vproto.pack_string_field(o.name, 2) +} + +if o.has_shortcutid { +res << vproto.pack_uint32_field(o.shortcutid, 3) +} + +if o.has_private { +res << vproto.pack_bool_field(o.private, 4) +} + +return res +} + +pub fn cpublishedfilegetuserfilesresponseapp_unpack(buf []byte) ?CPublishedFileGetUserFilesResponseApp { +mut res := CPublishedFileGetUserFilesResponseApp{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +3 { +res.has_shortcutid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.shortcutid = v +i = ii +} + +4 { +res.has_private = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.private = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilegetuserfilesresponseapp() CPublishedFileGetUserFilesResponseApp { +return CPublishedFileGetUserFilesResponseApp{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilegetuserfilesresponseapp(o CPublishedFileGetUserFilesResponseApp, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilegetuserfilesresponseapp(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileGetUserFilesResponseApp) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilegetuserfilesresponseapp_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileGetUserFilesResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +total u32 +has_total bool +startindex u32 +has_startindex bool +publishedfiledetails []PublishedFileDetails +apps []CPublishedFileGetUserFilesResponseApp +} +pub fn (o &CPublishedFileGetUserFilesResponse) pack() []byte { +mut res := []byte{} +if o.has_total { +res << vproto.pack_uint32_field(o.total, 1) +} + +if o.has_startindex { +res << vproto.pack_uint32_field(o.startindex, 2) +} + +// [packed=false] +for _, x in o.publishedfiledetails { +res << zzz_vproto_internal_pack_publishedfiledetails(x, 3) +} + +// [packed=false] +for _, x in o.apps { +res << zzz_vproto_internal_pack_cpublishedfilegetuserfilesresponseapp(x, 4) +} + +return res +} + +pub fn cpublishedfilegetuserfilesresponse_unpack(buf []byte) ?CPublishedFileGetUserFilesResponse { +mut res := CPublishedFileGetUserFilesResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_total = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.total = v +i = ii +} + +2 { +res.has_startindex = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.startindex = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_publishedfiledetails(cur_buf, tag_wiretype.wire_type)? +res.publishedfiledetails << v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cpublishedfilegetuserfilesresponseapp(cur_buf, tag_wiretype.wire_type)? +res.apps << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilegetuserfilesresponse() CPublishedFileGetUserFilesResponse { +return CPublishedFileGetUserFilesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilegetuserfilesresponse(o CPublishedFileGetUserFilesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilegetuserfilesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileGetUserFilesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilegetuserfilesresponse_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileAreFilesInSubscriptionListRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +publishedfileids []u64 +listtype u32 +has_listtype bool +filetype u32 +has_filetype bool +workshopfiletype u32 +has_workshopfiletype bool +} +pub fn (o &CPublishedFileAreFilesInSubscriptionListRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +// [packed=false] +for _, x in o.publishedfileids { +res << vproto.pack_64bit_field(x, 2) +} + +if o.has_listtype { +res << vproto.pack_uint32_field(o.listtype, 3) +} + +if o.has_filetype { +res << vproto.pack_uint32_field(o.filetype, 4) +} + +if o.has_workshopfiletype { +res << vproto.pack_uint32_field(o.workshopfiletype, 5) +} + +return res +} + +pub fn cpublishedfilearefilesinsubscriptionlistrequest_unpack(buf []byte) ?CPublishedFileAreFilesInSubscriptionListRequest { +mut res := CPublishedFileAreFilesInSubscriptionListRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.publishedfileids << v +i = ii +} + +3 { +res.has_listtype = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.listtype = v +i = ii +} + +4 { +res.has_filetype = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.filetype = v +i = ii +} + +5 { +res.has_workshopfiletype = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.workshopfiletype = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilearefilesinsubscriptionlistrequest() CPublishedFileAreFilesInSubscriptionListRequest { +return CPublishedFileAreFilesInSubscriptionListRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilearefilesinsubscriptionlistrequest(o CPublishedFileAreFilesInSubscriptionListRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilearefilesinsubscriptionlistrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileAreFilesInSubscriptionListRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilearefilesinsubscriptionlistrequest_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileAreFilesInSubscriptionListResponseInList { +mut: +unknown_fields []vproto.UnknownField +pub mut: +publishedfileid u64 +has_publishedfileid bool +inlist bool +has_inlist bool +} +pub fn (o &CPublishedFileAreFilesInSubscriptionListResponseInList) pack() []byte { +mut res := []byte{} +if o.has_publishedfileid { +res << vproto.pack_64bit_field(o.publishedfileid, 1) +} + +if o.has_inlist { +res << vproto.pack_bool_field(o.inlist, 2) +} + +return res +} + +pub fn cpublishedfilearefilesinsubscriptionlistresponseinlist_unpack(buf []byte) ?CPublishedFileAreFilesInSubscriptionListResponseInList { +mut res := CPublishedFileAreFilesInSubscriptionListResponseInList{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_publishedfileid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.publishedfileid = v +i = ii +} + +2 { +res.has_inlist = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.inlist = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilearefilesinsubscriptionlistresponseinlist() CPublishedFileAreFilesInSubscriptionListResponseInList { +return CPublishedFileAreFilesInSubscriptionListResponseInList{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilearefilesinsubscriptionlistresponseinlist(o CPublishedFileAreFilesInSubscriptionListResponseInList, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilearefilesinsubscriptionlistresponseinlist(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileAreFilesInSubscriptionListResponseInList) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilearefilesinsubscriptionlistresponseinlist_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileAreFilesInSubscriptionListResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +files []CPublishedFileAreFilesInSubscriptionListResponseInList +} +pub fn (o &CPublishedFileAreFilesInSubscriptionListResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.files { +res << zzz_vproto_internal_pack_cpublishedfilearefilesinsubscriptionlistresponseinlist(x, 1) +} + +return res +} + +pub fn cpublishedfilearefilesinsubscriptionlistresponse_unpack(buf []byte) ?CPublishedFileAreFilesInSubscriptionListResponse { +mut res := CPublishedFileAreFilesInSubscriptionListResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cpublishedfilearefilesinsubscriptionlistresponseinlist(cur_buf, tag_wiretype.wire_type)? +res.files << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilearefilesinsubscriptionlistresponse() CPublishedFileAreFilesInSubscriptionListResponse { +return CPublishedFileAreFilesInSubscriptionListResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilearefilesinsubscriptionlistresponse(o CPublishedFileAreFilesInSubscriptionListResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilearefilesinsubscriptionlistresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileAreFilesInSubscriptionListResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilearefilesinsubscriptionlistresponse_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileUpdateRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +publishedfileid u64 +has_publishedfileid bool +title string +has_title bool +file_description string +has_file_description bool +visibility u32 +has_visibility bool +tags []string +filename string +has_filename bool +preview_filename string +has_preview_filename bool +image_width u32 +has_image_width bool +image_height u32 +has_image_height bool +} +pub fn (o &CPublishedFileUpdateRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_publishedfileid { +res << vproto.pack_64bit_field(o.publishedfileid, 2) +} + +if o.has_title { +res << vproto.pack_string_field(o.title, 3) +} + +if o.has_file_description { +res << vproto.pack_string_field(o.file_description, 4) +} + +if o.has_visibility { +res << vproto.pack_uint32_field(o.visibility, 5) +} + +// [packed=false] +for _, x in o.tags { +res << vproto.pack_string_field(x, 6) +} + +if o.has_filename { +res << vproto.pack_string_field(o.filename, 7) +} + +if o.has_preview_filename { +res << vproto.pack_string_field(o.preview_filename, 8) +} + +if o.has_image_width { +res << vproto.pack_uint32_field(o.image_width, 15) +} + +if o.has_image_height { +res << vproto.pack_uint32_field(o.image_height, 16) +} + +return res +} + +pub fn cpublishedfileupdaterequest_unpack(buf []byte) ?CPublishedFileUpdateRequest { +mut res := CPublishedFileUpdateRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_publishedfileid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.publishedfileid = v +i = ii +} + +3 { +res.has_title = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.title = v +i = ii +} + +4 { +res.has_file_description = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.file_description = v +i = ii +} + +5 { +res.has_visibility = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.visibility = v +i = ii +} + +6 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.tags << v +i = ii +} + +7 { +res.has_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.filename = v +i = ii +} + +8 { +res.has_preview_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.preview_filename = v +i = ii +} + +15 { +res.has_image_width = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.image_width = v +i = ii +} + +16 { +res.has_image_height = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.image_height = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfileupdaterequest() CPublishedFileUpdateRequest { +return CPublishedFileUpdateRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfileupdaterequest(o CPublishedFileUpdateRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfileupdaterequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileUpdateRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfileupdaterequest_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileUpdateResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPublishedFileUpdateResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cpublishedfileupdateresponse_unpack(buf []byte) ?CPublishedFileUpdateResponse { +res := CPublishedFileUpdateResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfileupdateresponse() CPublishedFileUpdateResponse { +return CPublishedFileUpdateResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfileupdateresponse(o CPublishedFileUpdateResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfileupdateresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileUpdateResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfileupdateresponse_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileGetChangeHistoryEntryRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +publishedfileid u64 +has_publishedfileid bool +timestamp u32 +has_timestamp bool +language int +has_language bool +} +pub fn (o &CPublishedFileGetChangeHistoryEntryRequest) pack() []byte { +mut res := []byte{} +if o.has_publishedfileid { +res << vproto.pack_64bit_field(o.publishedfileid, 1) +} + +if o.has_timestamp { +res << vproto.pack_uint32_field(o.timestamp, 2) +} + +if o.has_language { +res << vproto.pack_int32_field(o.language, 3) +} + +return res +} + +pub fn cpublishedfilegetchangehistoryentryrequest_unpack(buf []byte) ?CPublishedFileGetChangeHistoryEntryRequest { +mut res := CPublishedFileGetChangeHistoryEntryRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_publishedfileid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.publishedfileid = v +i = ii +} + +2 { +res.has_timestamp = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp = v +i = ii +} + +3 { +res.has_language = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilegetchangehistoryentryrequest() CPublishedFileGetChangeHistoryEntryRequest { +return CPublishedFileGetChangeHistoryEntryRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilegetchangehistoryentryrequest(o CPublishedFileGetChangeHistoryEntryRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilegetchangehistoryentryrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileGetChangeHistoryEntryRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilegetchangehistoryentryrequest_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileGetChangeHistoryEntryResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +change_description string +has_change_description bool +language int +has_language bool +} +pub fn (o &CPublishedFileGetChangeHistoryEntryResponse) pack() []byte { +mut res := []byte{} +if o.has_change_description { +res << vproto.pack_string_field(o.change_description, 1) +} + +if o.has_language { +res << vproto.pack_int32_field(o.language, 2) +} + +return res +} + +pub fn cpublishedfilegetchangehistoryentryresponse_unpack(buf []byte) ?CPublishedFileGetChangeHistoryEntryResponse { +mut res := CPublishedFileGetChangeHistoryEntryResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_change_description = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.change_description = v +i = ii +} + +2 { +res.has_language = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilegetchangehistoryentryresponse() CPublishedFileGetChangeHistoryEntryResponse { +return CPublishedFileGetChangeHistoryEntryResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilegetchangehistoryentryresponse(o CPublishedFileGetChangeHistoryEntryResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilegetchangehistoryentryresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileGetChangeHistoryEntryResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilegetchangehistoryentryresponse_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileGetChangeHistoryRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +publishedfileid u64 +has_publishedfileid bool +total_only bool +has_total_only bool +startindex u32 +has_startindex bool +count u32 +has_count bool +language int +has_language bool +} +pub fn (o &CPublishedFileGetChangeHistoryRequest) pack() []byte { +mut res := []byte{} +if o.has_publishedfileid { +res << vproto.pack_64bit_field(o.publishedfileid, 1) +} + +if o.has_total_only { +res << vproto.pack_bool_field(o.total_only, 2) +} + +if o.has_startindex { +res << vproto.pack_uint32_field(o.startindex, 3) +} + +if o.has_count { +res << vproto.pack_uint32_field(o.count, 4) +} + +if o.has_language { +res << vproto.pack_int32_field(o.language, 5) +} + +return res +} + +pub fn cpublishedfilegetchangehistoryrequest_unpack(buf []byte) ?CPublishedFileGetChangeHistoryRequest { +mut res := CPublishedFileGetChangeHistoryRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_publishedfileid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.publishedfileid = v +i = ii +} + +2 { +res.has_total_only = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.total_only = v +i = ii +} + +3 { +res.has_startindex = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.startindex = v +i = ii +} + +4 { +res.has_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.count = v +i = ii +} + +5 { +res.has_language = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilegetchangehistoryrequest() CPublishedFileGetChangeHistoryRequest { +return CPublishedFileGetChangeHistoryRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilegetchangehistoryrequest(o CPublishedFileGetChangeHistoryRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilegetchangehistoryrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileGetChangeHistoryRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilegetchangehistoryrequest_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileGetChangeHistoryResponseChangeLog { +mut: +unknown_fields []vproto.UnknownField +pub mut: +timestamp u32 +has_timestamp bool +change_description string +has_change_description bool +language int +has_language bool +} +pub fn (o &CPublishedFileGetChangeHistoryResponseChangeLog) pack() []byte { +mut res := []byte{} +if o.has_timestamp { +res << vproto.pack_uint32_field(o.timestamp, 1) +} + +if o.has_change_description { +res << vproto.pack_string_field(o.change_description, 2) +} + +if o.has_language { +res << vproto.pack_int32_field(o.language, 3) +} + +return res +} + +pub fn cpublishedfilegetchangehistoryresponsechangelog_unpack(buf []byte) ?CPublishedFileGetChangeHistoryResponseChangeLog { +mut res := CPublishedFileGetChangeHistoryResponseChangeLog{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_timestamp = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp = v +i = ii +} + +2 { +res.has_change_description = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.change_description = v +i = ii +} + +3 { +res.has_language = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilegetchangehistoryresponsechangelog() CPublishedFileGetChangeHistoryResponseChangeLog { +return CPublishedFileGetChangeHistoryResponseChangeLog{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilegetchangehistoryresponsechangelog(o CPublishedFileGetChangeHistoryResponseChangeLog, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilegetchangehistoryresponsechangelog(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileGetChangeHistoryResponseChangeLog) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilegetchangehistoryresponsechangelog_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileGetChangeHistoryResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +changes []CPublishedFileGetChangeHistoryResponseChangeLog +total u32 +has_total bool +} +pub fn (o &CPublishedFileGetChangeHistoryResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.changes { +res << zzz_vproto_internal_pack_cpublishedfilegetchangehistoryresponsechangelog(x, 1) +} + +if o.has_total { +res << vproto.pack_uint32_field(o.total, 2) +} + +return res +} + +pub fn cpublishedfilegetchangehistoryresponse_unpack(buf []byte) ?CPublishedFileGetChangeHistoryResponse { +mut res := CPublishedFileGetChangeHistoryResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cpublishedfilegetchangehistoryresponsechangelog(cur_buf, tag_wiretype.wire_type)? +res.changes << v +i = ii +} + +2 { +res.has_total = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.total = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilegetchangehistoryresponse() CPublishedFileGetChangeHistoryResponse { +return CPublishedFileGetChangeHistoryResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilegetchangehistoryresponse(o CPublishedFileGetChangeHistoryResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilegetchangehistoryresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileGetChangeHistoryResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilegetchangehistoryresponse_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileRefreshVotingQueueRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +matching_file_type u32 +has_matching_file_type bool +tags []string +match_all_tags bool +has_match_all_tags bool +excluded_tags []string +desired_queue_size u32 +has_desired_queue_size bool +desired_revision EPublishedFileRevision +has_desired_revision bool +} +pub fn (o &CPublishedFileRefreshVotingQueueRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_matching_file_type { +res << vproto.pack_uint32_field(o.matching_file_type, 2) +} + +// [packed=false] +for _, x in o.tags { +res << vproto.pack_string_field(x, 3) +} + +if o.has_match_all_tags { +res << vproto.pack_bool_field(o.match_all_tags, 4) +} + +// [packed=false] +for _, x in o.excluded_tags { +res << vproto.pack_string_field(x, 5) +} + +if o.has_desired_queue_size { +res << vproto.pack_uint32_field(o.desired_queue_size, 6) +} + +if o.has_desired_revision { +res << zzz_vproto_internal_pack_epublishedfilerevision(o.desired_revision, 8) +} + +return res +} + +pub fn cpublishedfilerefreshvotingqueuerequest_unpack(buf []byte) ?CPublishedFileRefreshVotingQueueRequest { +mut res := CPublishedFileRefreshVotingQueueRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_matching_file_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.matching_file_type = v +i = ii +} + +3 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.tags << v +i = ii +} + +4 { +res.has_match_all_tags = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.match_all_tags = v +i = ii +} + +5 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.excluded_tags << v +i = ii +} + +6 { +res.has_desired_queue_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.desired_queue_size = v +i = ii +} + +8 { +res.has_desired_revision = true +ii, v := zzz_vproto_internal_unpack_epublishedfilerevision(cur_buf, tag_wiretype.wire_type)? +res.desired_revision = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilerefreshvotingqueuerequest() CPublishedFileRefreshVotingQueueRequest { +return CPublishedFileRefreshVotingQueueRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilerefreshvotingqueuerequest(o CPublishedFileRefreshVotingQueueRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilerefreshvotingqueuerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileRefreshVotingQueueRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilerefreshvotingqueuerequest_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileRefreshVotingQueueResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPublishedFileRefreshVotingQueueResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cpublishedfilerefreshvotingqueueresponse_unpack(buf []byte) ?CPublishedFileRefreshVotingQueueResponse { +res := CPublishedFileRefreshVotingQueueResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilerefreshvotingqueueresponse() CPublishedFileRefreshVotingQueueResponse { +return CPublishedFileRefreshVotingQueueResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilerefreshvotingqueueresponse(o CPublishedFileRefreshVotingQueueResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilerefreshvotingqueueresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileRefreshVotingQueueResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilerefreshvotingqueueresponse_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileQueryFilesRequestKVtag { +mut: +unknown_fields []vproto.UnknownField +pub mut: +key string +has_key bool +value string +has_value bool +} +pub fn (o &CPublishedFileQueryFilesRequestKVtag) pack() []byte { +mut res := []byte{} +if o.has_key { +res << vproto.pack_string_field(o.key, 1) +} + +if o.has_value { +res << vproto.pack_string_field(o.value, 2) +} + +return res +} + +pub fn cpublishedfilequeryfilesrequestkvtag_unpack(buf []byte) ?CPublishedFileQueryFilesRequestKVtag { +mut res := CPublishedFileQueryFilesRequestKVtag{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_key = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.key = v +i = ii +} + +2 { +res.has_value = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.value = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilequeryfilesrequestkvtag() CPublishedFileQueryFilesRequestKVtag { +return CPublishedFileQueryFilesRequestKVtag{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilequeryfilesrequestkvtag(o CPublishedFileQueryFilesRequestKVtag, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilequeryfilesrequestkvtag(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileQueryFilesRequestKVtag) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilequeryfilesrequestkvtag_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileQueryFilesRequestTagGroup { +mut: +unknown_fields []vproto.UnknownField +pub mut: +tags []string +} +pub fn (o &CPublishedFileQueryFilesRequestTagGroup) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.tags { +res << vproto.pack_string_field(x, 1) +} + +return res +} + +pub fn cpublishedfilequeryfilesrequesttaggroup_unpack(buf []byte) ?CPublishedFileQueryFilesRequestTagGroup { +mut res := CPublishedFileQueryFilesRequestTagGroup{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.tags << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilequeryfilesrequesttaggroup() CPublishedFileQueryFilesRequestTagGroup { +return CPublishedFileQueryFilesRequestTagGroup{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilequeryfilesrequesttaggroup(o CPublishedFileQueryFilesRequestTagGroup, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilequeryfilesrequesttaggroup(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileQueryFilesRequestTagGroup) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilequeryfilesrequesttaggroup_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileQueryFilesRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +query_type u32 +has_query_type bool +page u32 +has_page bool +cursor string +has_cursor bool +numperpage u32 +has_numperpage bool +creator_appid u32 +has_creator_appid bool +appid u32 +has_appid bool +requiredtags []string +excludedtags []string +match_all_tags bool +has_match_all_tags bool +required_flags []string +omitted_flags []string +search_text string +has_search_text bool +filetype u32 +has_filetype bool +child_publishedfileid u64 +has_child_publishedfileid bool +days u32 +has_days bool +include_recent_votes_only bool +has_include_recent_votes_only bool +cache_max_age_seconds u32 +has_cache_max_age_seconds bool +language int +has_language bool +required_kv_tags []CPublishedFileQueryFilesRequestKVtag +taggroups []CPublishedFileQueryFilesRequestTagGroup +totalonly bool +has_totalonly bool +ids_only bool +has_ids_only bool +return_vote_data bool +has_return_vote_data bool +return_tags bool +has_return_tags bool +return_kv_tags bool +has_return_kv_tags bool +return_previews bool +has_return_previews bool +return_children bool +has_return_children bool +return_short_description bool +has_return_short_description bool +return_for_sale_data bool +has_return_for_sale_data bool +return_metadata bool +has_return_metadata bool +return_playtime_stats u32 +has_return_playtime_stats bool +return_details bool +has_return_details bool +strip_description_bbcode bool +has_strip_description_bbcode bool +desired_revision EPublishedFileRevision +has_desired_revision bool +return_reactions bool +has_return_reactions bool +} +pub fn (o &CPublishedFileQueryFilesRequest) pack() []byte { +mut res := []byte{} +if o.has_query_type { +res << vproto.pack_uint32_field(o.query_type, 1) +} + +if o.has_page { +res << vproto.pack_uint32_field(o.page, 2) +} + +if o.has_cursor { +res << vproto.pack_string_field(o.cursor, 39) +} + +if o.has_numperpage { +res << vproto.pack_uint32_field(o.numperpage, 3) +} + +if o.has_creator_appid { +res << vproto.pack_uint32_field(o.creator_appid, 4) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 5) +} + +// [packed=false] +for _, x in o.requiredtags { +res << vproto.pack_string_field(x, 6) +} + +// [packed=false] +for _, x in o.excludedtags { +res << vproto.pack_string_field(x, 7) +} + +if o.has_match_all_tags { +res << vproto.pack_bool_field(o.match_all_tags, 8) +} + +// [packed=false] +for _, x in o.required_flags { +res << vproto.pack_string_field(x, 9) +} + +// [packed=false] +for _, x in o.omitted_flags { +res << vproto.pack_string_field(x, 10) +} + +if o.has_search_text { +res << vproto.pack_string_field(o.search_text, 11) +} + +if o.has_filetype { +res << vproto.pack_uint32_field(o.filetype, 12) +} + +if o.has_child_publishedfileid { +res << vproto.pack_64bit_field(o.child_publishedfileid, 13) +} + +if o.has_days { +res << vproto.pack_uint32_field(o.days, 14) +} + +if o.has_include_recent_votes_only { +res << vproto.pack_bool_field(o.include_recent_votes_only, 15) +} + +if o.has_cache_max_age_seconds { +res << vproto.pack_uint32_field(o.cache_max_age_seconds, 31) +} + +if o.has_language { +res << vproto.pack_int32_field(o.language, 33) +} + +// [packed=false] +for _, x in o.required_kv_tags { +res << zzz_vproto_internal_pack_cpublishedfilequeryfilesrequestkvtag(x, 34) +} + +// [packed=false] +for _, x in o.taggroups { +res << zzz_vproto_internal_pack_cpublishedfilequeryfilesrequesttaggroup(x, 42) +} + +if o.has_totalonly { +res << vproto.pack_bool_field(o.totalonly, 16) +} + +if o.has_ids_only { +res << vproto.pack_bool_field(o.ids_only, 35) +} + +if o.has_return_vote_data { +res << vproto.pack_bool_field(o.return_vote_data, 17) +} + +if o.has_return_tags { +res << vproto.pack_bool_field(o.return_tags, 18) +} + +if o.has_return_kv_tags { +res << vproto.pack_bool_field(o.return_kv_tags, 19) +} + +if o.has_return_previews { +res << vproto.pack_bool_field(o.return_previews, 20) +} + +if o.has_return_children { +res << vproto.pack_bool_field(o.return_children, 21) +} + +if o.has_return_short_description { +res << vproto.pack_bool_field(o.return_short_description, 22) +} + +if o.has_return_for_sale_data { +res << vproto.pack_bool_field(o.return_for_sale_data, 30) +} + +if o.has_return_metadata { +res << vproto.pack_bool_field(o.return_metadata, 32) +} + +if o.has_return_playtime_stats { +res << vproto.pack_uint32_field(o.return_playtime_stats, 36) +} + +if o.has_return_details { +res << vproto.pack_bool_field(o.return_details, 37) +} + +if o.has_strip_description_bbcode { +res << vproto.pack_bool_field(o.strip_description_bbcode, 38) +} + +if o.has_desired_revision { +res << zzz_vproto_internal_pack_epublishedfilerevision(o.desired_revision, 40) +} + +if o.has_return_reactions { +res << vproto.pack_bool_field(o.return_reactions, 43) +} + +return res +} + +pub fn cpublishedfilequeryfilesrequest_unpack(buf []byte) ?CPublishedFileQueryFilesRequest { +mut res := CPublishedFileQueryFilesRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_query_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.query_type = v +i = ii +} + +2 { +res.has_page = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.page = v +i = ii +} + +39 { +res.has_cursor = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.cursor = v +i = ii +} + +3 { +res.has_numperpage = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.numperpage = v +i = ii +} + +4 { +res.has_creator_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.creator_appid = v +i = ii +} + +5 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +6 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.requiredtags << v +i = ii +} + +7 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.excludedtags << v +i = ii +} + +8 { +res.has_match_all_tags = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.match_all_tags = v +i = ii +} + +9 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.required_flags << v +i = ii +} + +10 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.omitted_flags << v +i = ii +} + +11 { +res.has_search_text = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.search_text = v +i = ii +} + +12 { +res.has_filetype = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.filetype = v +i = ii +} + +13 { +res.has_child_publishedfileid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.child_publishedfileid = v +i = ii +} + +14 { +res.has_days = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.days = v +i = ii +} + +15 { +res.has_include_recent_votes_only = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.include_recent_votes_only = v +i = ii +} + +31 { +res.has_cache_max_age_seconds = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cache_max_age_seconds = v +i = ii +} + +33 { +res.has_language = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +34 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cpublishedfilequeryfilesrequestkvtag(cur_buf, tag_wiretype.wire_type)? +res.required_kv_tags << v +i = ii +} + +42 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cpublishedfilequeryfilesrequesttaggroup(cur_buf, tag_wiretype.wire_type)? +res.taggroups << v +i = ii +} + +16 { +res.has_totalonly = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.totalonly = v +i = ii +} + +35 { +res.has_ids_only = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.ids_only = v +i = ii +} + +17 { +res.has_return_vote_data = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.return_vote_data = v +i = ii +} + +18 { +res.has_return_tags = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.return_tags = v +i = ii +} + +19 { +res.has_return_kv_tags = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.return_kv_tags = v +i = ii +} + +20 { +res.has_return_previews = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.return_previews = v +i = ii +} + +21 { +res.has_return_children = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.return_children = v +i = ii +} + +22 { +res.has_return_short_description = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.return_short_description = v +i = ii +} + +30 { +res.has_return_for_sale_data = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.return_for_sale_data = v +i = ii +} + +32 { +res.has_return_metadata = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.return_metadata = v +i = ii +} + +36 { +res.has_return_playtime_stats = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.return_playtime_stats = v +i = ii +} + +37 { +res.has_return_details = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.return_details = v +i = ii +} + +38 { +res.has_strip_description_bbcode = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.strip_description_bbcode = v +i = ii +} + +40 { +res.has_desired_revision = true +ii, v := zzz_vproto_internal_unpack_epublishedfilerevision(cur_buf, tag_wiretype.wire_type)? +res.desired_revision = v +i = ii +} + +43 { +res.has_return_reactions = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.return_reactions = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilequeryfilesrequest() CPublishedFileQueryFilesRequest { +return CPublishedFileQueryFilesRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilequeryfilesrequest(o CPublishedFileQueryFilesRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilequeryfilesrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileQueryFilesRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilequeryfilesrequest_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileQueryFilesResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +total u32 +has_total bool +publishedfiledetails []PublishedFileDetails +next_cursor string +has_next_cursor bool +} +pub fn (o &CPublishedFileQueryFilesResponse) pack() []byte { +mut res := []byte{} +if o.has_total { +res << vproto.pack_uint32_field(o.total, 1) +} + +// [packed=false] +for _, x in o.publishedfiledetails { +res << zzz_vproto_internal_pack_publishedfiledetails(x, 2) +} + +if o.has_next_cursor { +res << vproto.pack_string_field(o.next_cursor, 3) +} + +return res +} + +pub fn cpublishedfilequeryfilesresponse_unpack(buf []byte) ?CPublishedFileQueryFilesResponse { +mut res := CPublishedFileQueryFilesResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_total = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.total = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_publishedfiledetails(cur_buf, tag_wiretype.wire_type)? +res.publishedfiledetails << v +i = ii +} + +3 { +res.has_next_cursor = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.next_cursor = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilequeryfilesresponse() CPublishedFileQueryFilesResponse { +return CPublishedFileQueryFilesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilequeryfilesresponse(o CPublishedFileQueryFilesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilequeryfilesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileQueryFilesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilequeryfilesresponse_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileAddAppRelationshipRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +publishedfileid u64 +has_publishedfileid bool +appid u32 +has_appid bool +relationship u32 +has_relationship bool +} +pub fn (o &CPublishedFileAddAppRelationshipRequest) pack() []byte { +mut res := []byte{} +if o.has_publishedfileid { +res << vproto.pack_uint64_field(o.publishedfileid, 1) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 2) +} + +if o.has_relationship { +res << vproto.pack_uint32_field(o.relationship, 3) +} + +return res +} + +pub fn cpublishedfileaddapprelationshiprequest_unpack(buf []byte) ?CPublishedFileAddAppRelationshipRequest { +mut res := CPublishedFileAddAppRelationshipRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_publishedfileid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.publishedfileid = v +i = ii +} + +2 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +3 { +res.has_relationship = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.relationship = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfileaddapprelationshiprequest() CPublishedFileAddAppRelationshipRequest { +return CPublishedFileAddAppRelationshipRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfileaddapprelationshiprequest(o CPublishedFileAddAppRelationshipRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfileaddapprelationshiprequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileAddAppRelationshipRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfileaddapprelationshiprequest_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileAddAppRelationshipResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPublishedFileAddAppRelationshipResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cpublishedfileaddapprelationshipresponse_unpack(buf []byte) ?CPublishedFileAddAppRelationshipResponse { +res := CPublishedFileAddAppRelationshipResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfileaddapprelationshipresponse() CPublishedFileAddAppRelationshipResponse { +return CPublishedFileAddAppRelationshipResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfileaddapprelationshipresponse(o CPublishedFileAddAppRelationshipResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfileaddapprelationshipresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileAddAppRelationshipResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfileaddapprelationshipresponse_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileRemoveAppRelationshipRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +publishedfileid u64 +has_publishedfileid bool +appid u32 +has_appid bool +relationship u32 +has_relationship bool +} +pub fn (o &CPublishedFileRemoveAppRelationshipRequest) pack() []byte { +mut res := []byte{} +if o.has_publishedfileid { +res << vproto.pack_uint64_field(o.publishedfileid, 1) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 2) +} + +if o.has_relationship { +res << vproto.pack_uint32_field(o.relationship, 3) +} + +return res +} + +pub fn cpublishedfileremoveapprelationshiprequest_unpack(buf []byte) ?CPublishedFileRemoveAppRelationshipRequest { +mut res := CPublishedFileRemoveAppRelationshipRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_publishedfileid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.publishedfileid = v +i = ii +} + +2 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +3 { +res.has_relationship = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.relationship = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfileremoveapprelationshiprequest() CPublishedFileRemoveAppRelationshipRequest { +return CPublishedFileRemoveAppRelationshipRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfileremoveapprelationshiprequest(o CPublishedFileRemoveAppRelationshipRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfileremoveapprelationshiprequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileRemoveAppRelationshipRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfileremoveapprelationshiprequest_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileRemoveAppRelationshipResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPublishedFileRemoveAppRelationshipResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cpublishedfileremoveapprelationshipresponse_unpack(buf []byte) ?CPublishedFileRemoveAppRelationshipResponse { +res := CPublishedFileRemoveAppRelationshipResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfileremoveapprelationshipresponse() CPublishedFileRemoveAppRelationshipResponse { +return CPublishedFileRemoveAppRelationshipResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfileremoveapprelationshipresponse(o CPublishedFileRemoveAppRelationshipResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfileremoveapprelationshipresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileRemoveAppRelationshipResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfileremoveapprelationshipresponse_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileGetAppRelationshipsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +publishedfileid u64 +has_publishedfileid bool +} +pub fn (o &CPublishedFileGetAppRelationshipsRequest) pack() []byte { +mut res := []byte{} +if o.has_publishedfileid { +res << vproto.pack_uint64_field(o.publishedfileid, 1) +} + +return res +} + +pub fn cpublishedfilegetapprelationshipsrequest_unpack(buf []byte) ?CPublishedFileGetAppRelationshipsRequest { +mut res := CPublishedFileGetAppRelationshipsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_publishedfileid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.publishedfileid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilegetapprelationshipsrequest() CPublishedFileGetAppRelationshipsRequest { +return CPublishedFileGetAppRelationshipsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilegetapprelationshipsrequest(o CPublishedFileGetAppRelationshipsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilegetapprelationshipsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileGetAppRelationshipsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilegetapprelationshipsrequest_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileGetAppRelationshipsResponseAppRelationship { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +relationship u32 +has_relationship bool +} +pub fn (o &CPublishedFileGetAppRelationshipsResponseAppRelationship) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_relationship { +res << vproto.pack_uint32_field(o.relationship, 2) +} + +return res +} + +pub fn cpublishedfilegetapprelationshipsresponseapprelationship_unpack(buf []byte) ?CPublishedFileGetAppRelationshipsResponseAppRelationship { +mut res := CPublishedFileGetAppRelationshipsResponseAppRelationship{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_relationship = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.relationship = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilegetapprelationshipsresponseapprelationship() CPublishedFileGetAppRelationshipsResponseAppRelationship { +return CPublishedFileGetAppRelationshipsResponseAppRelationship{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilegetapprelationshipsresponseapprelationship(o CPublishedFileGetAppRelationshipsResponseAppRelationship, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilegetapprelationshipsresponseapprelationship(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileGetAppRelationshipsResponseAppRelationship) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilegetapprelationshipsresponseapprelationship_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileGetAppRelationshipsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_relationships []CPublishedFileGetAppRelationshipsResponseAppRelationship +} +pub fn (o &CPublishedFileGetAppRelationshipsResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.app_relationships { +res << zzz_vproto_internal_pack_cpublishedfilegetapprelationshipsresponseapprelationship(x, 3) +} + +return res +} + +pub fn cpublishedfilegetapprelationshipsresponse_unpack(buf []byte) ?CPublishedFileGetAppRelationshipsResponse { +mut res := CPublishedFileGetAppRelationshipsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cpublishedfilegetapprelationshipsresponseapprelationship(cur_buf, tag_wiretype.wire_type)? +res.app_relationships << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilegetapprelationshipsresponse() CPublishedFileGetAppRelationshipsResponse { +return CPublishedFileGetAppRelationshipsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilegetapprelationshipsresponse(o CPublishedFileGetAppRelationshipsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilegetapprelationshipsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileGetAppRelationshipsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilegetapprelationshipsresponse_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileStartPlaytimeTrackingRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +publishedfileids []u64 +} +pub fn (o &CPublishedFileStartPlaytimeTrackingRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +// [packed=false] +for _, x in o.publishedfileids { +res << vproto.pack_uint64_field(x, 2) +} + +return res +} + +pub fn cpublishedfilestartplaytimetrackingrequest_unpack(buf []byte) ?CPublishedFileStartPlaytimeTrackingRequest { +mut res := CPublishedFileStartPlaytimeTrackingRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.publishedfileids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilestartplaytimetrackingrequest() CPublishedFileStartPlaytimeTrackingRequest { +return CPublishedFileStartPlaytimeTrackingRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilestartplaytimetrackingrequest(o CPublishedFileStartPlaytimeTrackingRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilestartplaytimetrackingrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileStartPlaytimeTrackingRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilestartplaytimetrackingrequest_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileStartPlaytimeTrackingResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPublishedFileStartPlaytimeTrackingResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cpublishedfilestartplaytimetrackingresponse_unpack(buf []byte) ?CPublishedFileStartPlaytimeTrackingResponse { +res := CPublishedFileStartPlaytimeTrackingResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilestartplaytimetrackingresponse() CPublishedFileStartPlaytimeTrackingResponse { +return CPublishedFileStartPlaytimeTrackingResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilestartplaytimetrackingresponse(o CPublishedFileStartPlaytimeTrackingResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilestartplaytimetrackingresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileStartPlaytimeTrackingResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilestartplaytimetrackingresponse_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileStopPlaytimeTrackingRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +publishedfileids []u64 +} +pub fn (o &CPublishedFileStopPlaytimeTrackingRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +// [packed=false] +for _, x in o.publishedfileids { +res << vproto.pack_uint64_field(x, 2) +} + +return res +} + +pub fn cpublishedfilestopplaytimetrackingrequest_unpack(buf []byte) ?CPublishedFileStopPlaytimeTrackingRequest { +mut res := CPublishedFileStopPlaytimeTrackingRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.publishedfileids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilestopplaytimetrackingrequest() CPublishedFileStopPlaytimeTrackingRequest { +return CPublishedFileStopPlaytimeTrackingRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilestopplaytimetrackingrequest(o CPublishedFileStopPlaytimeTrackingRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilestopplaytimetrackingrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileStopPlaytimeTrackingRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilestopplaytimetrackingrequest_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileStopPlaytimeTrackingResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPublishedFileStopPlaytimeTrackingResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cpublishedfilestopplaytimetrackingresponse_unpack(buf []byte) ?CPublishedFileStopPlaytimeTrackingResponse { +res := CPublishedFileStopPlaytimeTrackingResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilestopplaytimetrackingresponse() CPublishedFileStopPlaytimeTrackingResponse { +return CPublishedFileStopPlaytimeTrackingResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilestopplaytimetrackingresponse(o CPublishedFileStopPlaytimeTrackingResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilestopplaytimetrackingresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileStopPlaytimeTrackingResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilestopplaytimetrackingresponse_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileStopPlaytimeTrackingForAllAppItemsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +} +pub fn (o &CPublishedFileStopPlaytimeTrackingForAllAppItemsRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +return res +} + +pub fn cpublishedfilestopplaytimetrackingforallappitemsrequest_unpack(buf []byte) ?CPublishedFileStopPlaytimeTrackingForAllAppItemsRequest { +mut res := CPublishedFileStopPlaytimeTrackingForAllAppItemsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilestopplaytimetrackingforallappitemsrequest() CPublishedFileStopPlaytimeTrackingForAllAppItemsRequest { +return CPublishedFileStopPlaytimeTrackingForAllAppItemsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilestopplaytimetrackingforallappitemsrequest(o CPublishedFileStopPlaytimeTrackingForAllAppItemsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilestopplaytimetrackingforallappitemsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileStopPlaytimeTrackingForAllAppItemsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilestopplaytimetrackingforallappitemsrequest_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileStopPlaytimeTrackingForAllAppItemsResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPublishedFileStopPlaytimeTrackingForAllAppItemsResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cpublishedfilestopplaytimetrackingforallappitemsresponse_unpack(buf []byte) ?CPublishedFileStopPlaytimeTrackingForAllAppItemsResponse { +res := CPublishedFileStopPlaytimeTrackingForAllAppItemsResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilestopplaytimetrackingforallappitemsresponse() CPublishedFileStopPlaytimeTrackingForAllAppItemsResponse { +return CPublishedFileStopPlaytimeTrackingForAllAppItemsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilestopplaytimetrackingforallappitemsresponse(o CPublishedFileStopPlaytimeTrackingForAllAppItemsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilestopplaytimetrackingforallappitemsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileStopPlaytimeTrackingForAllAppItemsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilestopplaytimetrackingforallappitemsresponse_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileSetPlaytimeForControllerConfigsRequestControllerConfigUsage { +mut: +unknown_fields []vproto.UnknownField +pub mut: +publishedfileid u64 +has_publishedfileid bool +seconds_active f32 +has_seconds_active bool +} +pub fn (o &CPublishedFileSetPlaytimeForControllerConfigsRequestControllerConfigUsage) pack() []byte { +mut res := []byte{} +if o.has_publishedfileid { +res << vproto.pack_uint64_field(o.publishedfileid, 1) +} + +if o.has_seconds_active { +res << vproto.pack_float_field(o.seconds_active, 2) +} + +return res +} + +pub fn cpublishedfilesetplaytimeforcontrollerconfigsrequestcontrollerconfigusage_unpack(buf []byte) ?CPublishedFileSetPlaytimeForControllerConfigsRequestControllerConfigUsage { +mut res := CPublishedFileSetPlaytimeForControllerConfigsRequestControllerConfigUsage{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_publishedfileid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.publishedfileid = v +i = ii +} + +2 { +res.has_seconds_active = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_active = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilesetplaytimeforcontrollerconfigsrequestcontrollerconfigusage() CPublishedFileSetPlaytimeForControllerConfigsRequestControllerConfigUsage { +return CPublishedFileSetPlaytimeForControllerConfigsRequestControllerConfigUsage{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilesetplaytimeforcontrollerconfigsrequestcontrollerconfigusage(o CPublishedFileSetPlaytimeForControllerConfigsRequestControllerConfigUsage, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilesetplaytimeforcontrollerconfigsrequestcontrollerconfigusage(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileSetPlaytimeForControllerConfigsRequestControllerConfigUsage) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilesetplaytimeforcontrollerconfigsrequestcontrollerconfigusage_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileSetPlaytimeForControllerConfigsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +controller_config_usage []CPublishedFileSetPlaytimeForControllerConfigsRequestControllerConfigUsage +} +pub fn (o &CPublishedFileSetPlaytimeForControllerConfigsRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +// [packed=false] +for _, x in o.controller_config_usage { +res << zzz_vproto_internal_pack_cpublishedfilesetplaytimeforcontrollerconfigsrequestcontrollerconfigusage(x, 2) +} + +return res +} + +pub fn cpublishedfilesetplaytimeforcontrollerconfigsrequest_unpack(buf []byte) ?CPublishedFileSetPlaytimeForControllerConfigsRequest { +mut res := CPublishedFileSetPlaytimeForControllerConfigsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cpublishedfilesetplaytimeforcontrollerconfigsrequestcontrollerconfigusage(cur_buf, tag_wiretype.wire_type)? +res.controller_config_usage << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilesetplaytimeforcontrollerconfigsrequest() CPublishedFileSetPlaytimeForControllerConfigsRequest { +return CPublishedFileSetPlaytimeForControllerConfigsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilesetplaytimeforcontrollerconfigsrequest(o CPublishedFileSetPlaytimeForControllerConfigsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilesetplaytimeforcontrollerconfigsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileSetPlaytimeForControllerConfigsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilesetplaytimeforcontrollerconfigsrequest_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileSetPlaytimeForControllerConfigsResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPublishedFileSetPlaytimeForControllerConfigsResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cpublishedfilesetplaytimeforcontrollerconfigsresponse_unpack(buf []byte) ?CPublishedFileSetPlaytimeForControllerConfigsResponse { +res := CPublishedFileSetPlaytimeForControllerConfigsResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilesetplaytimeforcontrollerconfigsresponse() CPublishedFileSetPlaytimeForControllerConfigsResponse { +return CPublishedFileSetPlaytimeForControllerConfigsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilesetplaytimeforcontrollerconfigsresponse(o CPublishedFileSetPlaytimeForControllerConfigsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilesetplaytimeforcontrollerconfigsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileSetPlaytimeForControllerConfigsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilesetplaytimeforcontrollerconfigsresponse_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileAddChildRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +publishedfileid u64 +has_publishedfileid bool +child_publishedfileid u64 +has_child_publishedfileid bool +} +pub fn (o &CPublishedFileAddChildRequest) pack() []byte { +mut res := []byte{} +if o.has_publishedfileid { +res << vproto.pack_uint64_field(o.publishedfileid, 1) +} + +if o.has_child_publishedfileid { +res << vproto.pack_uint64_field(o.child_publishedfileid, 2) +} + +return res +} + +pub fn cpublishedfileaddchildrequest_unpack(buf []byte) ?CPublishedFileAddChildRequest { +mut res := CPublishedFileAddChildRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_publishedfileid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.publishedfileid = v +i = ii +} + +2 { +res.has_child_publishedfileid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.child_publishedfileid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfileaddchildrequest() CPublishedFileAddChildRequest { +return CPublishedFileAddChildRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfileaddchildrequest(o CPublishedFileAddChildRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfileaddchildrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileAddChildRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfileaddchildrequest_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileAddChildResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPublishedFileAddChildResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cpublishedfileaddchildresponse_unpack(buf []byte) ?CPublishedFileAddChildResponse { +res := CPublishedFileAddChildResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfileaddchildresponse() CPublishedFileAddChildResponse { +return CPublishedFileAddChildResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfileaddchildresponse(o CPublishedFileAddChildResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfileaddchildresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileAddChildResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfileaddchildresponse_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileRemoveChildRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +publishedfileid u64 +has_publishedfileid bool +child_publishedfileid u64 +has_child_publishedfileid bool +} +pub fn (o &CPublishedFileRemoveChildRequest) pack() []byte { +mut res := []byte{} +if o.has_publishedfileid { +res << vproto.pack_uint64_field(o.publishedfileid, 1) +} + +if o.has_child_publishedfileid { +res << vproto.pack_uint64_field(o.child_publishedfileid, 2) +} + +return res +} + +pub fn cpublishedfileremovechildrequest_unpack(buf []byte) ?CPublishedFileRemoveChildRequest { +mut res := CPublishedFileRemoveChildRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_publishedfileid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.publishedfileid = v +i = ii +} + +2 { +res.has_child_publishedfileid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.child_publishedfileid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfileremovechildrequest() CPublishedFileRemoveChildRequest { +return CPublishedFileRemoveChildRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfileremovechildrequest(o CPublishedFileRemoveChildRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfileremovechildrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileRemoveChildRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfileremovechildrequest_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileRemoveChildResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPublishedFileRemoveChildResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cpublishedfileremovechildresponse_unpack(buf []byte) ?CPublishedFileRemoveChildResponse { +res := CPublishedFileRemoveChildResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfileremovechildresponse() CPublishedFileRemoveChildResponse { +return CPublishedFileRemoveChildResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfileremovechildresponse(o CPublishedFileRemoveChildResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfileremovechildresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileRemoveChildResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfileremovechildresponse_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileGetUserVoteSummaryRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +publishedfileids []u64 +} +pub fn (o &CPublishedFileGetUserVoteSummaryRequest) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.publishedfileids { +res << vproto.pack_64bit_field(x, 1) +} + +return res +} + +pub fn cpublishedfilegetuservotesummaryrequest_unpack(buf []byte) ?CPublishedFileGetUserVoteSummaryRequest { +mut res := CPublishedFileGetUserVoteSummaryRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.publishedfileids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilegetuservotesummaryrequest() CPublishedFileGetUserVoteSummaryRequest { +return CPublishedFileGetUserVoteSummaryRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilegetuservotesummaryrequest(o CPublishedFileGetUserVoteSummaryRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilegetuservotesummaryrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileGetUserVoteSummaryRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilegetuservotesummaryrequest_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileGetUserVoteSummaryResponseVoteSummary { +mut: +unknown_fields []vproto.UnknownField +pub mut: +publishedfileid u64 +has_publishedfileid bool +vote_for bool +has_vote_for bool +vote_against bool +has_vote_against bool +reported bool +has_reported bool +} +pub fn (o &CPublishedFileGetUserVoteSummaryResponseVoteSummary) pack() []byte { +mut res := []byte{} +if o.has_publishedfileid { +res << vproto.pack_64bit_field(o.publishedfileid, 1) +} + +if o.has_vote_for { +res << vproto.pack_bool_field(o.vote_for, 2) +} + +if o.has_vote_against { +res << vproto.pack_bool_field(o.vote_against, 3) +} + +if o.has_reported { +res << vproto.pack_bool_field(o.reported, 4) +} + +return res +} + +pub fn cpublishedfilegetuservotesummaryresponsevotesummary_unpack(buf []byte) ?CPublishedFileGetUserVoteSummaryResponseVoteSummary { +mut res := CPublishedFileGetUserVoteSummaryResponseVoteSummary{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_publishedfileid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.publishedfileid = v +i = ii +} + +2 { +res.has_vote_for = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.vote_for = v +i = ii +} + +3 { +res.has_vote_against = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.vote_against = v +i = ii +} + +4 { +res.has_reported = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.reported = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilegetuservotesummaryresponsevotesummary() CPublishedFileGetUserVoteSummaryResponseVoteSummary { +return CPublishedFileGetUserVoteSummaryResponseVoteSummary{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilegetuservotesummaryresponsevotesummary(o CPublishedFileGetUserVoteSummaryResponseVoteSummary, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilegetuservotesummaryresponsevotesummary(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileGetUserVoteSummaryResponseVoteSummary) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilegetuservotesummaryresponsevotesummary_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileGetUserVoteSummaryResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +summaries []CPublishedFileGetUserVoteSummaryResponseVoteSummary +} +pub fn (o &CPublishedFileGetUserVoteSummaryResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.summaries { +res << zzz_vproto_internal_pack_cpublishedfilegetuservotesummaryresponsevotesummary(x, 1) +} + +return res +} + +pub fn cpublishedfilegetuservotesummaryresponse_unpack(buf []byte) ?CPublishedFileGetUserVoteSummaryResponse { +mut res := CPublishedFileGetUserVoteSummaryResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cpublishedfilegetuservotesummaryresponsevotesummary(cur_buf, tag_wiretype.wire_type)? +res.summaries << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilegetuservotesummaryresponse() CPublishedFileGetUserVoteSummaryResponse { +return CPublishedFileGetUserVoteSummaryResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilegetuservotesummaryresponse(o CPublishedFileGetUserVoteSummaryResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilegetuservotesummaryresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileGetUserVoteSummaryResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilegetuservotesummaryresponse_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileFileSubscribedNotificationRevisionData { +mut: +unknown_fields []vproto.UnknownField +pub mut: +revision EPublishedFileRevision +has_revision bool +file_hcontent u64 +has_file_hcontent bool +rtime_updated u32 +has_rtime_updated bool +} +pub fn (o &CPublishedFileFileSubscribedNotificationRevisionData) pack() []byte { +mut res := []byte{} +if o.has_revision { +res << zzz_vproto_internal_pack_epublishedfilerevision(o.revision, 1) +} + +if o.has_file_hcontent { +res << vproto.pack_64bit_field(o.file_hcontent, 2) +} + +if o.has_rtime_updated { +res << vproto.pack_uint32_field(o.rtime_updated, 3) +} + +return res +} + +pub fn cpublishedfilefilesubscribednotificationrevisiondata_unpack(buf []byte) ?CPublishedFileFileSubscribedNotificationRevisionData { +mut res := CPublishedFileFileSubscribedNotificationRevisionData{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_revision = true +ii, v := zzz_vproto_internal_unpack_epublishedfilerevision(cur_buf, tag_wiretype.wire_type)? +res.revision = v +i = ii +} + +2 { +res.has_file_hcontent = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.file_hcontent = v +i = ii +} + +3 { +res.has_rtime_updated = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rtime_updated = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilefilesubscribednotificationrevisiondata() CPublishedFileFileSubscribedNotificationRevisionData { +return CPublishedFileFileSubscribedNotificationRevisionData{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilefilesubscribednotificationrevisiondata(o CPublishedFileFileSubscribedNotificationRevisionData, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilefilesubscribednotificationrevisiondata(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileFileSubscribedNotificationRevisionData) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilefilesubscribednotificationrevisiondata_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileFileSubscribedNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +published_file_id u64 +has_published_file_id bool +app_id u32 +has_app_id bool +file_hcontent u64 +has_file_hcontent bool +file_size u32 +has_file_size bool +rtime_subscribed u32 +has_rtime_subscribed bool +is_depot_content bool +has_is_depot_content bool +rtime_updated u32 +has_rtime_updated bool +revisions []CPublishedFileFileSubscribedNotificationRevisionData +} +pub fn (o &CPublishedFileFileSubscribedNotification) pack() []byte { +mut res := []byte{} +if o.has_published_file_id { +res << vproto.pack_64bit_field(o.published_file_id, 1) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 2) +} + +if o.has_file_hcontent { +res << vproto.pack_64bit_field(o.file_hcontent, 3) +} + +if o.has_file_size { +res << vproto.pack_uint32_field(o.file_size, 4) +} + +if o.has_rtime_subscribed { +res << vproto.pack_uint32_field(o.rtime_subscribed, 5) +} + +if o.has_is_depot_content { +res << vproto.pack_bool_field(o.is_depot_content, 6) +} + +if o.has_rtime_updated { +res << vproto.pack_uint32_field(o.rtime_updated, 7) +} + +// [packed=false] +for _, x in o.revisions { +res << zzz_vproto_internal_pack_cpublishedfilefilesubscribednotificationrevisiondata(x, 8) +} + +return res +} + +pub fn cpublishedfilefilesubscribednotification_unpack(buf []byte) ?CPublishedFileFileSubscribedNotification { +mut res := CPublishedFileFileSubscribedNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_published_file_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.published_file_id = v +i = ii +} + +2 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +3 { +res.has_file_hcontent = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.file_hcontent = v +i = ii +} + +4 { +res.has_file_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.file_size = v +i = ii +} + +5 { +res.has_rtime_subscribed = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rtime_subscribed = v +i = ii +} + +6 { +res.has_is_depot_content = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_depot_content = v +i = ii +} + +7 { +res.has_rtime_updated = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rtime_updated = v +i = ii +} + +8 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cpublishedfilefilesubscribednotificationrevisiondata(cur_buf, tag_wiretype.wire_type)? +res.revisions << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilefilesubscribednotification() CPublishedFileFileSubscribedNotification { +return CPublishedFileFileSubscribedNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilefilesubscribednotification(o CPublishedFileFileSubscribedNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilefilesubscribednotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileFileSubscribedNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilefilesubscribednotification_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileFileUnsubscribedNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +published_file_id u64 +has_published_file_id bool +app_id u32 +has_app_id bool +} +pub fn (o &CPublishedFileFileUnsubscribedNotification) pack() []byte { +mut res := []byte{} +if o.has_published_file_id { +res << vproto.pack_64bit_field(o.published_file_id, 1) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 2) +} + +return res +} + +pub fn cpublishedfilefileunsubscribednotification_unpack(buf []byte) ?CPublishedFileFileUnsubscribedNotification { +mut res := CPublishedFileFileUnsubscribedNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_published_file_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.published_file_id = v +i = ii +} + +2 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilefileunsubscribednotification() CPublishedFileFileUnsubscribedNotification { +return CPublishedFileFileUnsubscribedNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilefileunsubscribednotification(o CPublishedFileFileUnsubscribedNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilefileunsubscribednotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileFileUnsubscribedNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilefileunsubscribednotification_unpack(v)? +return i, unpacked +} +pub struct CPublishedFileFileDeletedClientNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +published_file_id u64 +has_published_file_id bool +app_id u32 +has_app_id bool +} +pub fn (o &CPublishedFileFileDeletedClientNotification) pack() []byte { +mut res := []byte{} +if o.has_published_file_id { +res << vproto.pack_64bit_field(o.published_file_id, 1) +} + +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 2) +} + +return res +} + +pub fn cpublishedfilefiledeletedclientnotification_unpack(buf []byte) ?CPublishedFileFileDeletedClientNotification { +mut res := CPublishedFileFileDeletedClientNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_published_file_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.published_file_id = v +i = ii +} + +2 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpublishedfilefiledeletedclientnotification() CPublishedFileFileDeletedClientNotification { +return CPublishedFileFileDeletedClientNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpublishedfilefiledeletedclientnotification(o CPublishedFileFileDeletedClientNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpublishedfilefiledeletedclientnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CPublishedFileFileDeletedClientNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpublishedfilefiledeletedclientnotification_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_qms.steamclient_pb.v b/proto/steammessages_qms.steamclient_pb.v new file mode 100644 index 0000000..4cb2179 --- /dev/null +++ b/proto/steammessages_qms.steamclient_pb.v @@ -0,0 +1,1114 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +[_allow_multiple_values] +enum EGameSearchAction { +k_egamesearchaction_none = 0 +k_egamesearchaction_accept = 1 +k_egamesearchaction_decline = 2 +k_egamesearchaction_cancel = 3 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_egamesearchaction(e EGameSearchAction, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_egamesearchaction(buf []byte, tag_wiretype vproto.WireType) ?(int, EGameSearchAction) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EGameSearchAction(v) +} +[_allow_multiple_values] +enum EGameSearchResult { +k_egamesearchresult_invalid = 0 +k_egamesearchresult_searchinprogress = 1 +k_egamesearchresult_searchfailednohosts = 2 +k_egamesearchresult_searchgamefound = 3 +k_egamesearchresult_searchcompleteaccepted = 4 +k_egamesearchresult_searchcompletedeclined = 5 +k_egamesearchresult_searchcanceled = 6 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_egamesearchresult(e EGameSearchResult, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_egamesearchresult(buf []byte, tag_wiretype vproto.WireType) ?(int, EGameSearchResult) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EGameSearchResult(v) +} +pub struct GameSearchParam { +mut: +unknown_fields []vproto.UnknownField +pub mut: +key_name string +has_key_name bool +value []string +} +pub fn (o &GameSearchParam) pack() []byte { +mut res := []byte{} +if o.has_key_name { +res << vproto.pack_string_field(o.key_name, 1) +} + +// [packed=false] +for _, x in o.value { +res << vproto.pack_string_field(x, 2) +} + +return res +} + +pub fn gamesearchparam_unpack(buf []byte) ?GameSearchParam { +mut res := GameSearchParam{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_key_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.key_name = v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.value << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_gamesearchparam() GameSearchParam { +return GameSearchParam{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_gamesearchparam(o GameSearchParam, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_gamesearchparam(buf []byte, tag_wiretype vproto.WireType) ?(int, GameSearchParam) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := gamesearchparam_unpack(v)? +return i, unpacked +} +pub struct CQueuedMatchmakingSearchForGameRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +action EGameSearchAction +has_action bool +params []GameSearchParam +player_min u32 +has_player_min bool +player_max u32 +has_player_max bool +steamidlobby u64 +has_steamidlobby bool +searchid u64 +has_searchid bool +} +pub fn (o &CQueuedMatchmakingSearchForGameRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_action { +res << zzz_vproto_internal_pack_egamesearchaction(o.action, 2) +} + +// [packed=false] +for _, x in o.params { +res << zzz_vproto_internal_pack_gamesearchparam(x, 3) +} + +if o.has_player_min { +res << vproto.pack_uint32_field(o.player_min, 4) +} + +if o.has_player_max { +res << vproto.pack_uint32_field(o.player_max, 5) +} + +if o.has_steamidlobby { +res << vproto.pack_64bit_field(o.steamidlobby, 6) +} + +if o.has_searchid { +res << vproto.pack_uint64_field(o.searchid, 7) +} + +return res +} + +pub fn cqueuedmatchmakingsearchforgamerequest_unpack(buf []byte) ?CQueuedMatchmakingSearchForGameRequest { +mut res := CQueuedMatchmakingSearchForGameRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_action = true +ii, v := zzz_vproto_internal_unpack_egamesearchaction(cur_buf, tag_wiretype.wire_type)? +res.action = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_gamesearchparam(cur_buf, tag_wiretype.wire_type)? +res.params << v +i = ii +} + +4 { +res.has_player_min = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.player_min = v +i = ii +} + +5 { +res.has_player_max = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.player_max = v +i = ii +} + +6 { +res.has_steamidlobby = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamidlobby = v +i = ii +} + +7 { +res.has_searchid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.searchid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cqueuedmatchmakingsearchforgamerequest() CQueuedMatchmakingSearchForGameRequest { +return CQueuedMatchmakingSearchForGameRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cqueuedmatchmakingsearchforgamerequest(o CQueuedMatchmakingSearchForGameRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cqueuedmatchmakingsearchforgamerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CQueuedMatchmakingSearchForGameRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cqueuedmatchmakingsearchforgamerequest_unpack(v)? +return i, unpacked +} +pub struct CQueuedMatchmakingSearchForGameResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +gamesearchresult EGameSearchResult +has_gamesearchresult bool +searchid u64 +has_searchid bool +seconds_time_estimate u32 +has_seconds_time_estimate bool +poll_frequency u32 +has_poll_frequency bool +count_searching u32 +has_count_searching bool +players_in_match u32 +has_players_in_match bool +players_accepted u32 +has_players_accepted bool +connect_string string +has_connect_string bool +steamidhost u64 +has_steamidhost bool +rtime_match_made u32 +has_rtime_match_made bool +rtime_now u32 +has_rtime_now bool +steamid_canceled_search u64 +has_steamid_canceled_search bool +} +pub fn (o &CQueuedMatchmakingSearchForGameResponse) pack() []byte { +mut res := []byte{} +if o.has_gamesearchresult { +res << zzz_vproto_internal_pack_egamesearchresult(o.gamesearchresult, 1) +} + +if o.has_searchid { +res << vproto.pack_uint64_field(o.searchid, 2) +} + +if o.has_seconds_time_estimate { +res << vproto.pack_uint32_field(o.seconds_time_estimate, 3) +} + +if o.has_poll_frequency { +res << vproto.pack_uint32_field(o.poll_frequency, 4) +} + +if o.has_count_searching { +res << vproto.pack_uint32_field(o.count_searching, 5) +} + +if o.has_players_in_match { +res << vproto.pack_uint32_field(o.players_in_match, 6) +} + +if o.has_players_accepted { +res << vproto.pack_uint32_field(o.players_accepted, 7) +} + +if o.has_connect_string { +res << vproto.pack_string_field(o.connect_string, 9) +} + +if o.has_steamidhost { +res << vproto.pack_64bit_field(o.steamidhost, 10) +} + +if o.has_rtime_match_made { +res << vproto.pack_uint32_field(o.rtime_match_made, 11) +} + +if o.has_rtime_now { +res << vproto.pack_uint32_field(o.rtime_now, 12) +} + +if o.has_steamid_canceled_search { +res << vproto.pack_64bit_field(o.steamid_canceled_search, 13) +} + +return res +} + +pub fn cqueuedmatchmakingsearchforgameresponse_unpack(buf []byte) ?CQueuedMatchmakingSearchForGameResponse { +mut res := CQueuedMatchmakingSearchForGameResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_gamesearchresult = true +ii, v := zzz_vproto_internal_unpack_egamesearchresult(cur_buf, tag_wiretype.wire_type)? +res.gamesearchresult = v +i = ii +} + +2 { +res.has_searchid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.searchid = v +i = ii +} + +3 { +res.has_seconds_time_estimate = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_time_estimate = v +i = ii +} + +4 { +res.has_poll_frequency = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.poll_frequency = v +i = ii +} + +5 { +res.has_count_searching = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.count_searching = v +i = ii +} + +6 { +res.has_players_in_match = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.players_in_match = v +i = ii +} + +7 { +res.has_players_accepted = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.players_accepted = v +i = ii +} + +9 { +res.has_connect_string = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.connect_string = v +i = ii +} + +10 { +res.has_steamidhost = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamidhost = v +i = ii +} + +11 { +res.has_rtime_match_made = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rtime_match_made = v +i = ii +} + +12 { +res.has_rtime_now = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rtime_now = v +i = ii +} + +13 { +res.has_steamid_canceled_search = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid_canceled_search = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cqueuedmatchmakingsearchforgameresponse() CQueuedMatchmakingSearchForGameResponse { +return CQueuedMatchmakingSearchForGameResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cqueuedmatchmakingsearchforgameresponse(o CQueuedMatchmakingSearchForGameResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cqueuedmatchmakingsearchforgameresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CQueuedMatchmakingSearchForGameResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cqueuedmatchmakingsearchforgameresponse_unpack(v)? +return i, unpacked +} +pub struct CQueuedMatchmakingGameHostSearchForPlayersRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +action EGameSearchAction +has_action bool +params []GameSearchParam +player_min u32 +has_player_min bool +player_max u32 +has_player_max bool +player_max_team_size u32 +has_player_max_team_size bool +connection_string string +has_connection_string bool +searchid u64 +has_searchid bool +} +pub fn (o &CQueuedMatchmakingGameHostSearchForPlayersRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_action { +res << zzz_vproto_internal_pack_egamesearchaction(o.action, 2) +} + +// [packed=false] +for _, x in o.params { +res << zzz_vproto_internal_pack_gamesearchparam(x, 3) +} + +if o.has_player_min { +res << vproto.pack_uint32_field(o.player_min, 4) +} + +if o.has_player_max { +res << vproto.pack_uint32_field(o.player_max, 5) +} + +if o.has_player_max_team_size { +res << vproto.pack_uint32_field(o.player_max_team_size, 6) +} + +if o.has_connection_string { +res << vproto.pack_string_field(o.connection_string, 7) +} + +if o.has_searchid { +res << vproto.pack_uint64_field(o.searchid, 8) +} + +return res +} + +pub fn cqueuedmatchmakinggamehostsearchforplayersrequest_unpack(buf []byte) ?CQueuedMatchmakingGameHostSearchForPlayersRequest { +mut res := CQueuedMatchmakingGameHostSearchForPlayersRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_action = true +ii, v := zzz_vproto_internal_unpack_egamesearchaction(cur_buf, tag_wiretype.wire_type)? +res.action = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_gamesearchparam(cur_buf, tag_wiretype.wire_type)? +res.params << v +i = ii +} + +4 { +res.has_player_min = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.player_min = v +i = ii +} + +5 { +res.has_player_max = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.player_max = v +i = ii +} + +6 { +res.has_player_max_team_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.player_max_team_size = v +i = ii +} + +7 { +res.has_connection_string = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.connection_string = v +i = ii +} + +8 { +res.has_searchid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.searchid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cqueuedmatchmakinggamehostsearchforplayersrequest() CQueuedMatchmakingGameHostSearchForPlayersRequest { +return CQueuedMatchmakingGameHostSearchForPlayersRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cqueuedmatchmakinggamehostsearchforplayersrequest(o CQueuedMatchmakingGameHostSearchForPlayersRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cqueuedmatchmakinggamehostsearchforplayersrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CQueuedMatchmakingGameHostSearchForPlayersRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cqueuedmatchmakinggamehostsearchforplayersrequest_unpack(v)? +return i, unpacked +} +pub struct PlayerFound { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +action EGameSearchAction +has_action bool +params []GameSearchParam +team_number u32 +has_team_number bool +} +pub fn (o &PlayerFound) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_action { +res << zzz_vproto_internal_pack_egamesearchaction(o.action, 2) +} + +// [packed=false] +for _, x in o.params { +res << zzz_vproto_internal_pack_gamesearchparam(x, 3) +} + +if o.has_team_number { +res << vproto.pack_uint32_field(o.team_number, 4) +} + +return res +} + +pub fn playerfound_unpack(buf []byte) ?PlayerFound { +mut res := PlayerFound{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_action = true +ii, v := zzz_vproto_internal_unpack_egamesearchaction(cur_buf, tag_wiretype.wire_type)? +res.action = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_gamesearchparam(cur_buf, tag_wiretype.wire_type)? +res.params << v +i = ii +} + +4 { +res.has_team_number = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.team_number = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_playerfound() PlayerFound { +return PlayerFound{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_playerfound(o PlayerFound, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_playerfound(buf []byte, tag_wiretype vproto.WireType) ?(int, PlayerFound) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := playerfound_unpack(v)? +return i, unpacked +} +pub struct CQueuedMatchmakingGameHostSearchForPlayersResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +gamesearchresult EGameSearchResult +has_gamesearchresult bool +searchid u64 +has_searchid bool +poll_frequency u32 +has_poll_frequency bool +matchid u64 +has_matchid bool +players []PlayerFound +rtime_match_made u32 +has_rtime_match_made bool +rtime_now u32 +has_rtime_now bool +} +pub fn (o &CQueuedMatchmakingGameHostSearchForPlayersResponse) pack() []byte { +mut res := []byte{} +if o.has_gamesearchresult { +res << zzz_vproto_internal_pack_egamesearchresult(o.gamesearchresult, 1) +} + +if o.has_searchid { +res << vproto.pack_uint64_field(o.searchid, 2) +} + +if o.has_poll_frequency { +res << vproto.pack_uint32_field(o.poll_frequency, 3) +} + +if o.has_matchid { +res << vproto.pack_uint64_field(o.matchid, 4) +} + +// [packed=false] +for _, x in o.players { +res << zzz_vproto_internal_pack_playerfound(x, 5) +} + +if o.has_rtime_match_made { +res << vproto.pack_uint32_field(o.rtime_match_made, 6) +} + +if o.has_rtime_now { +res << vproto.pack_uint32_field(o.rtime_now, 7) +} + +return res +} + +pub fn cqueuedmatchmakinggamehostsearchforplayersresponse_unpack(buf []byte) ?CQueuedMatchmakingGameHostSearchForPlayersResponse { +mut res := CQueuedMatchmakingGameHostSearchForPlayersResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_gamesearchresult = true +ii, v := zzz_vproto_internal_unpack_egamesearchresult(cur_buf, tag_wiretype.wire_type)? +res.gamesearchresult = v +i = ii +} + +2 { +res.has_searchid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.searchid = v +i = ii +} + +3 { +res.has_poll_frequency = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.poll_frequency = v +i = ii +} + +4 { +res.has_matchid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.matchid = v +i = ii +} + +5 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_playerfound(cur_buf, tag_wiretype.wire_type)? +res.players << v +i = ii +} + +6 { +res.has_rtime_match_made = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rtime_match_made = v +i = ii +} + +7 { +res.has_rtime_now = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rtime_now = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cqueuedmatchmakinggamehostsearchforplayersresponse() CQueuedMatchmakingGameHostSearchForPlayersResponse { +return CQueuedMatchmakingGameHostSearchForPlayersResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cqueuedmatchmakinggamehostsearchforplayersresponse(o CQueuedMatchmakingGameHostSearchForPlayersResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cqueuedmatchmakinggamehostsearchforplayersresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CQueuedMatchmakingGameHostSearchForPlayersResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cqueuedmatchmakinggamehostsearchforplayersresponse_unpack(v)? +return i, unpacked +} +pub struct PlayerResult { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +value u32 +has_value bool +} +pub fn (o &PlayerResult) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_value { +res << vproto.pack_uint32_field(o.value, 2) +} + +return res +} + +pub fn playerresult_unpack(buf []byte) ?PlayerResult { +mut res := PlayerResult{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_value = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.value = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_playerresult() PlayerResult { +return PlayerResult{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_playerresult(o PlayerResult, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_playerresult(buf []byte, tag_wiretype vproto.WireType) ?(int, PlayerResult) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := playerresult_unpack(v)? +return i, unpacked +} +pub struct CQueuedMatchmakingGameHostSubmitPlayerResultRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +matchid u64 +has_matchid bool +player_results []PlayerResult +} +pub fn (o &CQueuedMatchmakingGameHostSubmitPlayerResultRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_matchid { +res << vproto.pack_uint64_field(o.matchid, 2) +} + +// [packed=false] +for _, x in o.player_results { +res << zzz_vproto_internal_pack_playerresult(x, 3) +} + +return res +} + +pub fn cqueuedmatchmakinggamehostsubmitplayerresultrequest_unpack(buf []byte) ?CQueuedMatchmakingGameHostSubmitPlayerResultRequest { +mut res := CQueuedMatchmakingGameHostSubmitPlayerResultRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_matchid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.matchid = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_playerresult(cur_buf, tag_wiretype.wire_type)? +res.player_results << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cqueuedmatchmakinggamehostsubmitplayerresultrequest() CQueuedMatchmakingGameHostSubmitPlayerResultRequest { +return CQueuedMatchmakingGameHostSubmitPlayerResultRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cqueuedmatchmakinggamehostsubmitplayerresultrequest(o CQueuedMatchmakingGameHostSubmitPlayerResultRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cqueuedmatchmakinggamehostsubmitplayerresultrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CQueuedMatchmakingGameHostSubmitPlayerResultRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cqueuedmatchmakinggamehostsubmitplayerresultrequest_unpack(v)? +return i, unpacked +} +pub struct CQueuedMatchmakingGameHostSubmitPlayerResultResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CQueuedMatchmakingGameHostSubmitPlayerResultResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cqueuedmatchmakinggamehostsubmitplayerresultresponse_unpack(buf []byte) ?CQueuedMatchmakingGameHostSubmitPlayerResultResponse { +res := CQueuedMatchmakingGameHostSubmitPlayerResultResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cqueuedmatchmakinggamehostsubmitplayerresultresponse() CQueuedMatchmakingGameHostSubmitPlayerResultResponse { +return CQueuedMatchmakingGameHostSubmitPlayerResultResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cqueuedmatchmakinggamehostsubmitplayerresultresponse(o CQueuedMatchmakingGameHostSubmitPlayerResultResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cqueuedmatchmakinggamehostsubmitplayerresultresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CQueuedMatchmakingGameHostSubmitPlayerResultResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cqueuedmatchmakinggamehostsubmitplayerresultresponse_unpack(v)? +return i, unpacked +} +pub struct CQueuedMatchmakingGameHostEndGameRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +matchid u64 +has_matchid bool +} +pub fn (o &CQueuedMatchmakingGameHostEndGameRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_matchid { +res << vproto.pack_uint64_field(o.matchid, 2) +} + +return res +} + +pub fn cqueuedmatchmakinggamehostendgamerequest_unpack(buf []byte) ?CQueuedMatchmakingGameHostEndGameRequest { +mut res := CQueuedMatchmakingGameHostEndGameRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_matchid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.matchid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cqueuedmatchmakinggamehostendgamerequest() CQueuedMatchmakingGameHostEndGameRequest { +return CQueuedMatchmakingGameHostEndGameRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cqueuedmatchmakinggamehostendgamerequest(o CQueuedMatchmakingGameHostEndGameRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cqueuedmatchmakinggamehostendgamerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CQueuedMatchmakingGameHostEndGameRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cqueuedmatchmakinggamehostendgamerequest_unpack(v)? +return i, unpacked +} +pub struct CQueuedMatchmakingGameHostEndGameResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CQueuedMatchmakingGameHostEndGameResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cqueuedmatchmakinggamehostendgameresponse_unpack(buf []byte) ?CQueuedMatchmakingGameHostEndGameResponse { +res := CQueuedMatchmakingGameHostEndGameResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cqueuedmatchmakinggamehostendgameresponse() CQueuedMatchmakingGameHostEndGameResponse { +return CQueuedMatchmakingGameHostEndGameResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cqueuedmatchmakinggamehostendgameresponse(o CQueuedMatchmakingGameHostEndGameResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cqueuedmatchmakinggamehostendgameresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CQueuedMatchmakingGameHostEndGameResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cqueuedmatchmakinggamehostendgameresponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_remoteclient_discovery_pb.v b/proto/steammessages_remoteclient_discovery_pb.v new file mode 100644 index 0000000..9f1efd1 --- /dev/null +++ b/proto/steammessages_remoteclient_discovery_pb.v @@ -0,0 +1,1937 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +[_allow_multiple_values] +enum ERemoteClientBroadcastMsg { +k_eremoteclientbroadcastmsgdiscovery = 0 +k_eremoteclientbroadcastmsgstatus = 1 +k_eremoteclientbroadcastmsgoffline = 2 +k_eremotedeviceauthorizationrequest = 3 +k_eremotedeviceauthorizationresponse = 4 +k_eremotedevicestreamingrequest = 5 +k_eremotedevicestreamingresponse = 6 +k_eremotedeviceproofrequest = 7 +k_eremotedeviceproofresponse = 8 +k_eremotedeviceauthorizationcancelrequest = 9 +k_eremotedevicestreamingcancelrequest = 10 +k_eremoteclientbroadcastmsgclientiddeconflict = 11 +k_eremotedevicestreamtransportsignal = 12 +k_eremotedevicestreamingprogress = 13 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_eremoteclientbroadcastmsg(e ERemoteClientBroadcastMsg, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_eremoteclientbroadcastmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, ERemoteClientBroadcastMsg) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, ERemoteClientBroadcastMsg(v) +} +[_allow_multiple_values] +enum ERemoteClientService { +k_eremoteclientservicenone = 0 +k_eremoteclientserviceremotecontrol = 1 +k_eremoteclientservicegamestreaming = 2 +k_eremoteclientservicesitelicense = 4 +k_eremoteclientservicecontentcache = 8 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_eremoteclientservice(e ERemoteClientService, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_eremoteclientservice(buf []byte, tag_wiretype vproto.WireType) ?(int, ERemoteClientService) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, ERemoteClientService(v) +} +[_allow_multiple_values] +enum ERemoteDeviceAuthorizationResult { +k_eremotedeviceauthorizationsuccess = 0 +k_eremotedeviceauthorizationdenied = 1 +k_eremotedeviceauthorizationnotloggedin = 2 +k_eremotedeviceauthorizationoffline = 3 +k_eremotedeviceauthorizationbusy = 4 +k_eremotedeviceauthorizationinprogress = 5 +k_eremotedeviceauthorizationtimedout = 6 +k_eremotedeviceauthorizationfailed = 7 +k_eremotedeviceauthorizationcanceled = 8 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_eremotedeviceauthorizationresult(e ERemoteDeviceAuthorizationResult, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_eremotedeviceauthorizationresult(buf []byte, tag_wiretype vproto.WireType) ?(int, ERemoteDeviceAuthorizationResult) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, ERemoteDeviceAuthorizationResult(v) +} +[_allow_multiple_values] +enum EStreamDeviceFormFactor { +k_estreamdeviceformfactorunknown = 0 +k_estreamdeviceformfactorphone = 1 +k_estreamdeviceformfactortablet = 2 +k_estreamdeviceformfactorcomputer = 3 +k_estreamdeviceformfactortv = 4 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_estreamdeviceformfactor(e EStreamDeviceFormFactor, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_estreamdeviceformfactor(buf []byte, tag_wiretype vproto.WireType) ?(int, EStreamDeviceFormFactor) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EStreamDeviceFormFactor(v) +} +[_allow_multiple_values] +enum EStreamTransport { +k_estreamtransportnone = 0 +k_estreamtransportudp = 1 +k_estreamtransportudprelay = 2 +k_estreamtransportwebrtc = 3 +k_estreamtransportsdr = 4 +k_estreamtransportudp_sns = 5 +k_estreamtransportudprelay_sns = 6 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_estreamtransport(e EStreamTransport, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_estreamtransport(buf []byte, tag_wiretype vproto.WireType) ?(int, EStreamTransport) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EStreamTransport(v) +} +[_allow_multiple_values] +enum EStreamInterface { +k_estreaminterfacedefault = 0 +k_estreaminterfacerecentgames = 1 +k_estreaminterfacebigpicture = 2 +k_estreaminterfacedesktop = 3 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_estreaminterface(e EStreamInterface, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_estreaminterface(buf []byte, tag_wiretype vproto.WireType) ?(int, EStreamInterface) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EStreamInterface(v) +} +[_allow_multiple_values] +enum ERemoteDeviceStreamingResult { +k_eremotedevicestreamingsuccess = 0 +k_eremotedevicestreamingunauthorized = 1 +k_eremotedevicestreamingscreenlocked = 2 +k_eremotedevicestreamingfailed = 3 +k_eremotedevicestreamingbusy = 4 +k_eremotedevicestreaminginprogress = 5 +k_eremotedevicestreamingcanceled = 6 +k_eremotedevicestreamingdriversnotinstalled = 7 +k_eremotedevicestreamingdisabled = 8 +k_eremotedevicestreamingbroadcastingactive = 9 +k_eremotedevicestreamingvractive = 10 +k_eremotedevicestreamingpinrequired = 11 +k_eremotedevicestreamingtransportunavailable = 12 +k_eremotedevicestreaminginvisible = 13 +k_eremotedevicestreaminggamelaunchfailed = 14 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_eremotedevicestreamingresult(e ERemoteDeviceStreamingResult, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_eremotedevicestreamingresult(buf []byte, tag_wiretype vproto.WireType) ?(int, ERemoteDeviceStreamingResult) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, ERemoteDeviceStreamingResult(v) +} +pub struct CMsgRemoteClientBroadcastHeader { +mut: +unknown_fields []vproto.UnknownField +pub mut: +client_id u64 +has_client_id bool +msg_type ERemoteClientBroadcastMsg +has_msg_type bool +instance_id u64 +has_instance_id bool +device_id u64 +has_device_id bool +device_token []byte +has_device_token bool +} +pub fn (o &CMsgRemoteClientBroadcastHeader) pack() []byte { +mut res := []byte{} +if o.has_client_id { +res << vproto.pack_uint64_field(o.client_id, 1) +} + +if o.has_msg_type { +res << zzz_vproto_internal_pack_eremoteclientbroadcastmsg(o.msg_type, 2) +} + +if o.has_instance_id { +res << vproto.pack_uint64_field(o.instance_id, 3) +} + +if o.has_device_id { +res << vproto.pack_uint64_field(o.device_id, 4) +} + +if o.has_device_token { +res << vproto.pack_bytes_field(o.device_token, 5) +} + +return res +} + +pub fn cmsgremoteclientbroadcastheader_unpack(buf []byte) ?CMsgRemoteClientBroadcastHeader { +mut res := CMsgRemoteClientBroadcastHeader{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_client_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.client_id = v +i = ii +} + +2 { +res.has_msg_type = true +ii, v := zzz_vproto_internal_unpack_eremoteclientbroadcastmsg(cur_buf, tag_wiretype.wire_type)? +res.msg_type = v +i = ii +} + +3 { +res.has_instance_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.instance_id = v +i = ii +} + +4 { +res.has_device_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.device_id = v +i = ii +} + +5 { +res.has_device_token = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.device_token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremoteclientbroadcastheader() CMsgRemoteClientBroadcastHeader { +return CMsgRemoteClientBroadcastHeader{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremoteclientbroadcastheader(o CMsgRemoteClientBroadcastHeader, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremoteclientbroadcastheader(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteClientBroadcastHeader) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremoteclientbroadcastheader_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteClientBroadcastStatusUser { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +auth_key_id u32 +has_auth_key_id bool +} +pub fn (o &CMsgRemoteClientBroadcastStatusUser) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_auth_key_id { +res << vproto.pack_uint32_field(o.auth_key_id, 2) +} + +return res +} + +pub fn cmsgremoteclientbroadcaststatususer_unpack(buf []byte) ?CMsgRemoteClientBroadcastStatusUser { +mut res := CMsgRemoteClientBroadcastStatusUser{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_auth_key_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.auth_key_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremoteclientbroadcaststatususer() CMsgRemoteClientBroadcastStatusUser { +return CMsgRemoteClientBroadcastStatusUser{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremoteclientbroadcaststatususer(o CMsgRemoteClientBroadcastStatusUser, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremoteclientbroadcaststatususer(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteClientBroadcastStatusUser) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremoteclientbroadcaststatususer_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteClientBroadcastStatus { +mut: +unknown_fields []vproto.UnknownField +pub mut: +version int +has_version bool +min_version int +has_min_version bool +connect_port u32 +has_connect_port bool +hostname string +has_hostname bool +enabled_services u32 +has_enabled_services bool +ostype int +has_ostype bool +is64bit bool +has_is64bit bool +users []CMsgRemoteClientBroadcastStatusUser +euniverse int +has_euniverse bool +timestamp u32 +has_timestamp bool +screen_locked bool +has_screen_locked bool +games_running bool +has_games_running bool +mac_addresses []string +download_lan_peer_group u32 +has_download_lan_peer_group bool +broadcasting_active bool +has_broadcasting_active bool +vr_active bool +has_vr_active bool +content_cache_port u32 +has_content_cache_port bool +ip_addresses []string +public_ip_address string +has_public_ip_address bool +remoteplay_active bool +has_remoteplay_active bool +} +pub fn (o &CMsgRemoteClientBroadcastStatus) pack() []byte { +mut res := []byte{} +if o.has_version { +res << vproto.pack_int32_field(o.version, 1) +} + +if o.has_min_version { +res << vproto.pack_int32_field(o.min_version, 2) +} + +if o.has_connect_port { +res << vproto.pack_uint32_field(o.connect_port, 3) +} + +if o.has_hostname { +res << vproto.pack_string_field(o.hostname, 4) +} + +if o.has_enabled_services { +res << vproto.pack_uint32_field(o.enabled_services, 6) +} + +if o.has_ostype { +res << vproto.pack_int32_field(o.ostype, 7) +} + +if o.has_is64bit { +res << vproto.pack_bool_field(o.is64bit, 8) +} + +// [packed=false] +for _, x in o.users { +res << zzz_vproto_internal_pack_cmsgremoteclientbroadcaststatususer(x, 9) +} + +if o.has_euniverse { +res << vproto.pack_int32_field(o.euniverse, 11) +} + +if o.has_timestamp { +res << vproto.pack_uint32_field(o.timestamp, 12) +} + +if o.has_screen_locked { +res << vproto.pack_bool_field(o.screen_locked, 13) +} + +if o.has_games_running { +res << vproto.pack_bool_field(o.games_running, 14) +} + +// [packed=false] +for _, x in o.mac_addresses { +res << vproto.pack_string_field(x, 15) +} + +if o.has_download_lan_peer_group { +res << vproto.pack_uint32_field(o.download_lan_peer_group, 16) +} + +if o.has_broadcasting_active { +res << vproto.pack_bool_field(o.broadcasting_active, 17) +} + +if o.has_vr_active { +res << vproto.pack_bool_field(o.vr_active, 18) +} + +if o.has_content_cache_port { +res << vproto.pack_uint32_field(o.content_cache_port, 19) +} + +// [packed=false] +for _, x in o.ip_addresses { +res << vproto.pack_string_field(x, 20) +} + +if o.has_public_ip_address { +res << vproto.pack_string_field(o.public_ip_address, 21) +} + +if o.has_remoteplay_active { +res << vproto.pack_bool_field(o.remoteplay_active, 22) +} + +return res +} + +pub fn cmsgremoteclientbroadcaststatus_unpack(buf []byte) ?CMsgRemoteClientBroadcastStatus { +mut res := CMsgRemoteClientBroadcastStatus{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_version = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.version = v +i = ii +} + +2 { +res.has_min_version = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.min_version = v +i = ii +} + +3 { +res.has_connect_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.connect_port = v +i = ii +} + +4 { +res.has_hostname = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.hostname = v +i = ii +} + +6 { +res.has_enabled_services = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.enabled_services = v +i = ii +} + +7 { +res.has_ostype = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.ostype = v +i = ii +} + +8 { +res.has_is64bit = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is64bit = v +i = ii +} + +9 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgremoteclientbroadcaststatususer(cur_buf, tag_wiretype.wire_type)? +res.users << v +i = ii +} + +11 { +res.has_euniverse = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.euniverse = v +i = ii +} + +12 { +res.has_timestamp = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp = v +i = ii +} + +13 { +res.has_screen_locked = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.screen_locked = v +i = ii +} + +14 { +res.has_games_running = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.games_running = v +i = ii +} + +15 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.mac_addresses << v +i = ii +} + +16 { +res.has_download_lan_peer_group = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.download_lan_peer_group = v +i = ii +} + +17 { +res.has_broadcasting_active = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.broadcasting_active = v +i = ii +} + +18 { +res.has_vr_active = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.vr_active = v +i = ii +} + +19 { +res.has_content_cache_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.content_cache_port = v +i = ii +} + +20 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.ip_addresses << v +i = ii +} + +21 { +res.has_public_ip_address = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.public_ip_address = v +i = ii +} + +22 { +res.has_remoteplay_active = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.remoteplay_active = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremoteclientbroadcaststatus() CMsgRemoteClientBroadcastStatus { +return CMsgRemoteClientBroadcastStatus{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremoteclientbroadcaststatus(o CMsgRemoteClientBroadcastStatus, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremoteclientbroadcaststatus(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteClientBroadcastStatus) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremoteclientbroadcaststatus_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteClientBroadcastDiscovery { +mut: +unknown_fields []vproto.UnknownField +pub mut: +seq_num u32 +has_seq_num bool +client_ids []u64 +} +pub fn (o &CMsgRemoteClientBroadcastDiscovery) pack() []byte { +mut res := []byte{} +if o.has_seq_num { +res << vproto.pack_uint32_field(o.seq_num, 1) +} + +// [packed=false] +for _, x in o.client_ids { +res << vproto.pack_uint64_field(x, 2) +} + +return res +} + +pub fn cmsgremoteclientbroadcastdiscovery_unpack(buf []byte) ?CMsgRemoteClientBroadcastDiscovery { +mut res := CMsgRemoteClientBroadcastDiscovery{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_seq_num = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seq_num = v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.client_ids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremoteclientbroadcastdiscovery() CMsgRemoteClientBroadcastDiscovery { +return CMsgRemoteClientBroadcastDiscovery{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremoteclientbroadcastdiscovery(o CMsgRemoteClientBroadcastDiscovery, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremoteclientbroadcastdiscovery(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteClientBroadcastDiscovery) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremoteclientbroadcastdiscovery_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteClientBroadcastClientIDdeconflict { +mut: +unknown_fields []vproto.UnknownField +pub mut: +client_ids []u64 +} +pub fn (o &CMsgRemoteClientBroadcastClientIDdeconflict) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.client_ids { +res << vproto.pack_uint64_field(x, 2) +} + +return res +} + +pub fn cmsgremoteclientbroadcastclientiddeconflict_unpack(buf []byte) ?CMsgRemoteClientBroadcastClientIDdeconflict { +mut res := CMsgRemoteClientBroadcastClientIDdeconflict{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +2 { +// [packed=false] +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.client_ids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremoteclientbroadcastclientiddeconflict() CMsgRemoteClientBroadcastClientIDdeconflict { +return CMsgRemoteClientBroadcastClientIDdeconflict{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremoteclientbroadcastclientiddeconflict(o CMsgRemoteClientBroadcastClientIDdeconflict, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremoteclientbroadcastclientiddeconflict(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteClientBroadcastClientIDdeconflict) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremoteclientbroadcastclientiddeconflict_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteDeviceAuthorizationRequestCKeyEscrowTicket { +mut: +unknown_fields []vproto.UnknownField +pub mut: +password []byte +has_password bool +identifier u64 +has_identifier bool +payload []byte +has_payload bool +timestamp u32 +has_timestamp bool +usage CMsgRemoteDeviceAuthorizationRequestEKeyEscrowUsage +has_usage bool +device_name string +has_device_name bool +device_model string +has_device_model bool +device_serial string +has_device_serial bool +device_provisioning_id u32 +has_device_provisioning_id bool +} +pub fn (o &CMsgRemoteDeviceAuthorizationRequestCKeyEscrowTicket) pack() []byte { +mut res := []byte{} +if o.has_password { +res << vproto.pack_bytes_field(o.password, 1) +} + +if o.has_identifier { +res << vproto.pack_uint64_field(o.identifier, 2) +} + +if o.has_payload { +res << vproto.pack_bytes_field(o.payload, 3) +} + +if o.has_timestamp { +res << vproto.pack_uint32_field(o.timestamp, 4) +} + +if o.has_usage { +res << zzz_vproto_internal_pack_cmsgremotedeviceauthorizationrequestekeyescrowusage(o.usage, 5) +} + +if o.has_device_name { +res << vproto.pack_string_field(o.device_name, 6) +} + +if o.has_device_model { +res << vproto.pack_string_field(o.device_model, 7) +} + +if o.has_device_serial { +res << vproto.pack_string_field(o.device_serial, 8) +} + +if o.has_device_provisioning_id { +res << vproto.pack_uint32_field(o.device_provisioning_id, 9) +} + +return res +} + +pub fn cmsgremotedeviceauthorizationrequestckeyescrowticket_unpack(buf []byte) ?CMsgRemoteDeviceAuthorizationRequestCKeyEscrowTicket { +mut res := CMsgRemoteDeviceAuthorizationRequestCKeyEscrowTicket{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_password = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.password = v +i = ii +} + +2 { +res.has_identifier = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.identifier = v +i = ii +} + +3 { +res.has_payload = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.payload = v +i = ii +} + +4 { +res.has_timestamp = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp = v +i = ii +} + +5 { +res.has_usage = true +ii, v := zzz_vproto_internal_unpack_cmsgremotedeviceauthorizationrequestekeyescrowusage(cur_buf, tag_wiretype.wire_type)? +res.usage = v +i = ii +} + +6 { +res.has_device_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.device_name = v +i = ii +} + +7 { +res.has_device_model = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.device_model = v +i = ii +} + +8 { +res.has_device_serial = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.device_serial = v +i = ii +} + +9 { +res.has_device_provisioning_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.device_provisioning_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremotedeviceauthorizationrequestckeyescrowticket() CMsgRemoteDeviceAuthorizationRequestCKeyEscrowTicket { +return CMsgRemoteDeviceAuthorizationRequestCKeyEscrowTicket{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremotedeviceauthorizationrequestckeyescrowticket(o CMsgRemoteDeviceAuthorizationRequestCKeyEscrowTicket, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremotedeviceauthorizationrequestckeyescrowticket(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteDeviceAuthorizationRequestCKeyEscrowTicket) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremotedeviceauthorizationrequestckeyescrowticket_unpack(v)? +return i, unpacked +} +[_allow_multiple_values] +enum CMsgRemoteDeviceAuthorizationRequestEKeyEscrowUsage { +k_ekeyescrowusagestreamingdevice = 0 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_cmsgremotedeviceauthorizationrequestekeyescrowusage(e CMsgRemoteDeviceAuthorizationRequestEKeyEscrowUsage, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_cmsgremotedeviceauthorizationrequestekeyescrowusage(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteDeviceAuthorizationRequestEKeyEscrowUsage) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, CMsgRemoteDeviceAuthorizationRequestEKeyEscrowUsage(v) +} +pub struct CMsgRemoteDeviceAuthorizationRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +device_token []byte +device_name string +has_device_name bool +encrypted_request []byte +} +pub fn (o &CMsgRemoteDeviceAuthorizationRequest) pack() []byte { +mut res := []byte{} +res << vproto.pack_bytes_field(o.device_token, 1) + +if o.has_device_name { +res << vproto.pack_string_field(o.device_name, 2) +} + +res << vproto.pack_bytes_field(o.encrypted_request, 3) + +return res +} + +pub fn cmsgremotedeviceauthorizationrequest_unpack(buf []byte) ?CMsgRemoteDeviceAuthorizationRequest { +mut res := CMsgRemoteDeviceAuthorizationRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.device_token = v +i = ii +} + +2 { +res.has_device_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.device_name = v +i = ii +} + +3 { +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.encrypted_request = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremotedeviceauthorizationrequest() CMsgRemoteDeviceAuthorizationRequest { +return CMsgRemoteDeviceAuthorizationRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremotedeviceauthorizationrequest(o CMsgRemoteDeviceAuthorizationRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremotedeviceauthorizationrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteDeviceAuthorizationRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremotedeviceauthorizationrequest_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteDeviceAuthorizationCancelRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CMsgRemoteDeviceAuthorizationCancelRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn cmsgremotedeviceauthorizationcancelrequest_unpack(buf []byte) ?CMsgRemoteDeviceAuthorizationCancelRequest { +res := CMsgRemoteDeviceAuthorizationCancelRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremotedeviceauthorizationcancelrequest() CMsgRemoteDeviceAuthorizationCancelRequest { +return CMsgRemoteDeviceAuthorizationCancelRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremotedeviceauthorizationcancelrequest(o CMsgRemoteDeviceAuthorizationCancelRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremotedeviceauthorizationcancelrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteDeviceAuthorizationCancelRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremotedeviceauthorizationcancelrequest_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteDeviceAuthorizationResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +result ERemoteDeviceAuthorizationResult +steamid u64 +has_steamid bool +} +pub fn (o &CMsgRemoteDeviceAuthorizationResponse) pack() []byte { +mut res := []byte{} +res << zzz_vproto_internal_pack_eremotedeviceauthorizationresult(o.result, 1) + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 2) +} + +return res +} + +pub fn cmsgremotedeviceauthorizationresponse_unpack(buf []byte) ?CMsgRemoteDeviceAuthorizationResponse { +mut res := CMsgRemoteDeviceAuthorizationResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := zzz_vproto_internal_unpack_eremotedeviceauthorizationresult(cur_buf, tag_wiretype.wire_type)? +res.result = v +i = ii +} + +2 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremotedeviceauthorizationresponse() CMsgRemoteDeviceAuthorizationResponse { +return CMsgRemoteDeviceAuthorizationResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremotedeviceauthorizationresponse(o CMsgRemoteDeviceAuthorizationResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremotedeviceauthorizationresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteDeviceAuthorizationResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremotedeviceauthorizationresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteDeviceStreamingRequestReservedGamepad { +mut: +unknown_fields []vproto.UnknownField +pub mut: +controller_type u32 +has_controller_type bool +controller_subtype u32 +has_controller_subtype bool +} +pub fn (o &CMsgRemoteDeviceStreamingRequestReservedGamepad) pack() []byte { +mut res := []byte{} +if o.has_controller_type { +res << vproto.pack_uint32_field(o.controller_type, 1) +} + +if o.has_controller_subtype { +res << vproto.pack_uint32_field(o.controller_subtype, 2) +} + +return res +} + +pub fn cmsgremotedevicestreamingrequestreservedgamepad_unpack(buf []byte) ?CMsgRemoteDeviceStreamingRequestReservedGamepad { +mut res := CMsgRemoteDeviceStreamingRequestReservedGamepad{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_controller_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.controller_type = v +i = ii +} + +2 { +res.has_controller_subtype = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.controller_subtype = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremotedevicestreamingrequestreservedgamepad() CMsgRemoteDeviceStreamingRequestReservedGamepad { +return CMsgRemoteDeviceStreamingRequestReservedGamepad{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremotedevicestreamingrequestreservedgamepad(o CMsgRemoteDeviceStreamingRequestReservedGamepad, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremotedevicestreamingrequestreservedgamepad(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteDeviceStreamingRequestReservedGamepad) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremotedevicestreamingrequestreservedgamepad_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteDeviceStreamingRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +request_id u32 +maximum_resolution_x int +has_maximum_resolution_x bool +maximum_resolution_y int +has_maximum_resolution_y bool +audio_channel_count int +has_audio_channel_count bool +device_version string +has_device_version bool +stream_desktop bool +has_stream_desktop bool +device_token []byte +has_device_token bool +pin []byte +has_pin bool +enable_video_streaming bool +has_enable_video_streaming bool +enable_audio_streaming bool +has_enable_audio_streaming bool +enable_input_streaming bool +has_enable_input_streaming bool +network_test bool +has_network_test bool +client_id u64 +has_client_id bool +supported_transport []EStreamTransport +restricted bool +has_restricted bool +form_factor EStreamDeviceFormFactor +has_form_factor bool +gamepad_count int +has_gamepad_count bool +gamepads []CMsgRemoteDeviceStreamingRequestReservedGamepad +gameid u64 +has_gameid bool +stream_interface EStreamInterface +has_stream_interface bool +} +pub fn (o &CMsgRemoteDeviceStreamingRequest) pack() []byte { +mut res := []byte{} +res << vproto.pack_uint32_field(o.request_id, 1) + +if o.has_maximum_resolution_x { +res << vproto.pack_int32_field(o.maximum_resolution_x, 2) +} + +if o.has_maximum_resolution_y { +res << vproto.pack_int32_field(o.maximum_resolution_y, 3) +} + +if o.has_audio_channel_count { +res << vproto.pack_int32_field(o.audio_channel_count, 4) +} + +if o.has_device_version { +res << vproto.pack_string_field(o.device_version, 5) +} + +if o.has_stream_desktop { +res << vproto.pack_bool_field(o.stream_desktop, 6) +} + +if o.has_device_token { +res << vproto.pack_bytes_field(o.device_token, 7) +} + +if o.has_pin { +res << vproto.pack_bytes_field(o.pin, 8) +} + +if o.has_enable_video_streaming { +res << vproto.pack_bool_field(o.enable_video_streaming, 9) +} + +if o.has_enable_audio_streaming { +res << vproto.pack_bool_field(o.enable_audio_streaming, 10) +} + +if o.has_enable_input_streaming { +res << vproto.pack_bool_field(o.enable_input_streaming, 11) +} + +if o.has_network_test { +res << vproto.pack_bool_field(o.network_test, 12) +} + +if o.has_client_id { +res << vproto.pack_uint64_field(o.client_id, 13) +} + +// [packed=false] +for _, x in o.supported_transport { +res << zzz_vproto_internal_pack_estreamtransport(x, 14) +} + +if o.has_restricted { +res << vproto.pack_bool_field(o.restricted, 15) +} + +if o.has_form_factor { +res << zzz_vproto_internal_pack_estreamdeviceformfactor(o.form_factor, 16) +} + +if o.has_gamepad_count { +res << vproto.pack_int32_field(o.gamepad_count, 17) +} + +// [packed=false] +for _, x in o.gamepads { +res << zzz_vproto_internal_pack_cmsgremotedevicestreamingrequestreservedgamepad(x, 18) +} + +if o.has_gameid { +res << vproto.pack_uint64_field(o.gameid, 19) +} + +if o.has_stream_interface { +res << zzz_vproto_internal_pack_estreaminterface(o.stream_interface, 20) +} + +return res +} + +pub fn cmsgremotedevicestreamingrequest_unpack(buf []byte) ?CMsgRemoteDeviceStreamingRequest { +mut res := CMsgRemoteDeviceStreamingRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.request_id = v +i = ii +} + +2 { +res.has_maximum_resolution_x = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.maximum_resolution_x = v +i = ii +} + +3 { +res.has_maximum_resolution_y = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.maximum_resolution_y = v +i = ii +} + +4 { +res.has_audio_channel_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.audio_channel_count = v +i = ii +} + +5 { +res.has_device_version = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.device_version = v +i = ii +} + +6 { +res.has_stream_desktop = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.stream_desktop = v +i = ii +} + +7 { +res.has_device_token = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.device_token = v +i = ii +} + +8 { +res.has_pin = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.pin = v +i = ii +} + +9 { +res.has_enable_video_streaming = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enable_video_streaming = v +i = ii +} + +10 { +res.has_enable_audio_streaming = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enable_audio_streaming = v +i = ii +} + +11 { +res.has_enable_input_streaming = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enable_input_streaming = v +i = ii +} + +12 { +res.has_network_test = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.network_test = v +i = ii +} + +13 { +res.has_client_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.client_id = v +i = ii +} + +14 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_estreamtransport(cur_buf, tag_wiretype.wire_type)? +res.supported_transport << v +i = ii +} + +15 { +res.has_restricted = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.restricted = v +i = ii +} + +16 { +res.has_form_factor = true +ii, v := zzz_vproto_internal_unpack_estreamdeviceformfactor(cur_buf, tag_wiretype.wire_type)? +res.form_factor = v +i = ii +} + +17 { +res.has_gamepad_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.gamepad_count = v +i = ii +} + +18 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgremotedevicestreamingrequestreservedgamepad(cur_buf, tag_wiretype.wire_type)? +res.gamepads << v +i = ii +} + +19 { +res.has_gameid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.gameid = v +i = ii +} + +20 { +res.has_stream_interface = true +ii, v := zzz_vproto_internal_unpack_estreaminterface(cur_buf, tag_wiretype.wire_type)? +res.stream_interface = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremotedevicestreamingrequest() CMsgRemoteDeviceStreamingRequest { +return CMsgRemoteDeviceStreamingRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremotedevicestreamingrequest(o CMsgRemoteDeviceStreamingRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremotedevicestreamingrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteDeviceStreamingRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremotedevicestreamingrequest_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteDeviceStreamingCancelRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +request_id u32 +} +pub fn (o &CMsgRemoteDeviceStreamingCancelRequest) pack() []byte { +mut res := []byte{} +res << vproto.pack_uint32_field(o.request_id, 1) + +return res +} + +pub fn cmsgremotedevicestreamingcancelrequest_unpack(buf []byte) ?CMsgRemoteDeviceStreamingCancelRequest { +mut res := CMsgRemoteDeviceStreamingCancelRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.request_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremotedevicestreamingcancelrequest() CMsgRemoteDeviceStreamingCancelRequest { +return CMsgRemoteDeviceStreamingCancelRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremotedevicestreamingcancelrequest(o CMsgRemoteDeviceStreamingCancelRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremotedevicestreamingcancelrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteDeviceStreamingCancelRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremotedevicestreamingcancelrequest_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteDeviceStreamingProgress { +mut: +unknown_fields []vproto.UnknownField +pub mut: +request_id u32 +progress f32 +has_progress bool +} +pub fn (o &CMsgRemoteDeviceStreamingProgress) pack() []byte { +mut res := []byte{} +res << vproto.pack_uint32_field(o.request_id, 1) + +if o.has_progress { +res << vproto.pack_float_field(o.progress, 2) +} + +return res +} + +pub fn cmsgremotedevicestreamingprogress_unpack(buf []byte) ?CMsgRemoteDeviceStreamingProgress { +mut res := CMsgRemoteDeviceStreamingProgress{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.request_id = v +i = ii +} + +2 { +res.has_progress = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.progress = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremotedevicestreamingprogress() CMsgRemoteDeviceStreamingProgress { +return CMsgRemoteDeviceStreamingProgress{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremotedevicestreamingprogress(o CMsgRemoteDeviceStreamingProgress, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremotedevicestreamingprogress(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteDeviceStreamingProgress) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremotedevicestreamingprogress_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteDeviceStreamingResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +request_id u32 +result ERemoteDeviceStreamingResult +port u32 +has_port bool +encrypted_session_key []byte +has_encrypted_session_key bool +transport EStreamTransport +has_transport bool +relay_server string +has_relay_server bool +cert string +has_cert bool +} +pub fn (o &CMsgRemoteDeviceStreamingResponse) pack() []byte { +mut res := []byte{} +res << vproto.pack_uint32_field(o.request_id, 1) + +res << zzz_vproto_internal_pack_eremotedevicestreamingresult(o.result, 2) + +if o.has_port { +res << vproto.pack_uint32_field(o.port, 3) +} + +if o.has_encrypted_session_key { +res << vproto.pack_bytes_field(o.encrypted_session_key, 4) +} + +if o.has_transport { +res << zzz_vproto_internal_pack_estreamtransport(o.transport, 6) +} + +if o.has_relay_server { +res << vproto.pack_string_field(o.relay_server, 7) +} + +if o.has_cert { +res << vproto.pack_string_field(o.cert, 8) +} + +return res +} + +pub fn cmsgremotedevicestreamingresponse_unpack(buf []byte) ?CMsgRemoteDeviceStreamingResponse { +mut res := CMsgRemoteDeviceStreamingResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.request_id = v +i = ii +} + +2 { +ii, v := zzz_vproto_internal_unpack_eremotedevicestreamingresult(cur_buf, tag_wiretype.wire_type)? +res.result = v +i = ii +} + +3 { +res.has_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.port = v +i = ii +} + +4 { +res.has_encrypted_session_key = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.encrypted_session_key = v +i = ii +} + +6 { +res.has_transport = true +ii, v := zzz_vproto_internal_unpack_estreamtransport(cur_buf, tag_wiretype.wire_type)? +res.transport = v +i = ii +} + +7 { +res.has_relay_server = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.relay_server = v +i = ii +} + +8 { +res.has_cert = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.cert = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremotedevicestreamingresponse() CMsgRemoteDeviceStreamingResponse { +return CMsgRemoteDeviceStreamingResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremotedevicestreamingresponse(o CMsgRemoteDeviceStreamingResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremotedevicestreamingresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteDeviceStreamingResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremotedevicestreamingresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteDeviceProofRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +challenge []byte +request_id u32 +has_request_id bool +} +pub fn (o &CMsgRemoteDeviceProofRequest) pack() []byte { +mut res := []byte{} +res << vproto.pack_bytes_field(o.challenge, 1) + +if o.has_request_id { +res << vproto.pack_uint32_field(o.request_id, 2) +} + +return res +} + +pub fn cmsgremotedeviceproofrequest_unpack(buf []byte) ?CMsgRemoteDeviceProofRequest { +mut res := CMsgRemoteDeviceProofRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.challenge = v +i = ii +} + +2 { +res.has_request_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.request_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremotedeviceproofrequest() CMsgRemoteDeviceProofRequest { +return CMsgRemoteDeviceProofRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremotedeviceproofrequest(o CMsgRemoteDeviceProofRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremotedeviceproofrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteDeviceProofRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremotedeviceproofrequest_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteDeviceProofResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +response []byte +request_id u32 +has_request_id bool +} +pub fn (o &CMsgRemoteDeviceProofResponse) pack() []byte { +mut res := []byte{} +res << vproto.pack_bytes_field(o.response, 1) + +if o.has_request_id { +res << vproto.pack_uint32_field(o.request_id, 2) +} + +return res +} + +pub fn cmsgremotedeviceproofresponse_unpack(buf []byte) ?CMsgRemoteDeviceProofResponse { +mut res := CMsgRemoteDeviceProofResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.response = v +i = ii +} + +2 { +res.has_request_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.request_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremotedeviceproofresponse() CMsgRemoteDeviceProofResponse { +return CMsgRemoteDeviceProofResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremotedeviceproofresponse(o CMsgRemoteDeviceProofResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremotedeviceproofresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteDeviceProofResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremotedeviceproofresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteDeviceStreamTransportSignal { +mut: +unknown_fields []vproto.UnknownField +pub mut: +token []byte +has_token bool +payload []byte +has_payload bool +} +pub fn (o &CMsgRemoteDeviceStreamTransportSignal) pack() []byte { +mut res := []byte{} +if o.has_token { +res << vproto.pack_bytes_field(o.token, 1) +} + +if o.has_payload { +res << vproto.pack_bytes_field(o.payload, 2) +} + +return res +} + +pub fn cmsgremotedevicestreamtransportsignal_unpack(buf []byte) ?CMsgRemoteDeviceStreamTransportSignal { +mut res := CMsgRemoteDeviceStreamTransportSignal{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_token = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.token = v +i = ii +} + +2 { +res.has_payload = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.payload = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremotedevicestreamtransportsignal() CMsgRemoteDeviceStreamTransportSignal { +return CMsgRemoteDeviceStreamTransportSignal{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremotedevicestreamtransportsignal(o CMsgRemoteDeviceStreamTransportSignal, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremotedevicestreamtransportsignal(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteDeviceStreamTransportSignal) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremotedevicestreamtransportsignal_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_remoteclient_pb.v b/proto/steammessages_remoteclient_pb.v new file mode 100644 index 0000000..a564a81 --- /dev/null +++ b/proto/steammessages_remoteclient_pb.v @@ -0,0 +1,1249 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CMsgRemoteClientStatus { +mut: +unknown_fields []vproto.UnknownField +pub mut: +client_id u64 +has_client_id bool +instance_id u64 +has_instance_id bool +status CMsgRemoteClientBroadcastStatus +has_status bool +} +pub fn (o &CMsgRemoteClientStatus) pack() []byte { +mut res := []byte{} +if o.has_client_id { +res << vproto.pack_uint64_field(o.client_id, 1) +} + +if o.has_instance_id { +res << vproto.pack_uint64_field(o.instance_id, 2) +} + +if o.has_status { +res << zzz_vproto_internal_pack_cmsgremoteclientbroadcaststatus(o.status, 3) +} + +return res +} + +pub fn cmsgremoteclientstatus_unpack(buf []byte) ?CMsgRemoteClientStatus { +mut res := CMsgRemoteClientStatus{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_client_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.client_id = v +i = ii +} + +2 { +res.has_instance_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.instance_id = v +i = ii +} + +3 { +res.has_status = true +ii, v := zzz_vproto_internal_unpack_cmsgremoteclientbroadcaststatus(cur_buf, tag_wiretype.wire_type)? +res.status = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremoteclientstatus() CMsgRemoteClientStatus { +return CMsgRemoteClientStatus{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremoteclientstatus(o CMsgRemoteClientStatus, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremoteclientstatus(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteClientStatus) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremoteclientstatus_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteClientAppStatusAppUpdateInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +time_update_start u32 +has_time_update_start bool +bytes_to_download u64 +has_bytes_to_download bool +bytes_downloaded u64 +has_bytes_downloaded bool +bytes_to_process u64 +has_bytes_to_process bool +bytes_processed u64 +has_bytes_processed bool +estimated_seconds_remaining int +has_estimated_seconds_remaining bool +update_result int +has_update_result bool +update_state u32 +has_update_state bool +} +pub fn (o &CMsgRemoteClientAppStatusAppUpdateInfo) pack() []byte { +mut res := []byte{} +if o.has_time_update_start { +res << vproto.pack_32bit_field(o.time_update_start, 1) +} + +if o.has_bytes_to_download { +res << vproto.pack_uint64_field(o.bytes_to_download, 2) +} + +if o.has_bytes_downloaded { +res << vproto.pack_uint64_field(o.bytes_downloaded, 3) +} + +if o.has_bytes_to_process { +res << vproto.pack_uint64_field(o.bytes_to_process, 4) +} + +if o.has_bytes_processed { +res << vproto.pack_uint64_field(o.bytes_processed, 5) +} + +if o.has_estimated_seconds_remaining { +res << vproto.pack_int32_field(o.estimated_seconds_remaining, 6) +} + +if o.has_update_result { +res << vproto.pack_int32_field(o.update_result, 7) +} + +if o.has_update_state { +res << vproto.pack_uint32_field(o.update_state, 8) +} + +return res +} + +pub fn cmsgremoteclientappstatusappupdateinfo_unpack(buf []byte) ?CMsgRemoteClientAppStatusAppUpdateInfo { +mut res := CMsgRemoteClientAppStatusAppUpdateInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_time_update_start = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.time_update_start = v +i = ii +} + +2 { +res.has_bytes_to_download = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.bytes_to_download = v +i = ii +} + +3 { +res.has_bytes_downloaded = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.bytes_downloaded = v +i = ii +} + +4 { +res.has_bytes_to_process = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.bytes_to_process = v +i = ii +} + +5 { +res.has_bytes_processed = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.bytes_processed = v +i = ii +} + +6 { +res.has_estimated_seconds_remaining = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.estimated_seconds_remaining = v +i = ii +} + +7 { +res.has_update_result = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.update_result = v +i = ii +} + +8 { +res.has_update_state = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.update_state = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremoteclientappstatusappupdateinfo() CMsgRemoteClientAppStatusAppUpdateInfo { +return CMsgRemoteClientAppStatusAppUpdateInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremoteclientappstatusappupdateinfo(o CMsgRemoteClientAppStatusAppUpdateInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremoteclientappstatusappupdateinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteClientAppStatusAppUpdateInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremoteclientappstatusappupdateinfo_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteClientAppStatusShortcutInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +name string +has_name bool +icon string +has_icon bool +categories []string +exepath string +has_exepath bool +} +pub fn (o &CMsgRemoteClientAppStatusShortcutInfo) pack() []byte { +mut res := []byte{} +if o.has_name { +res << vproto.pack_string_field(o.name, 1) +} + +if o.has_icon { +res << vproto.pack_string_field(o.icon, 2) +} + +// [packed=false] +for _, x in o.categories { +res << vproto.pack_string_field(x, 3) +} + +if o.has_exepath { +res << vproto.pack_string_field(o.exepath, 4) +} + +return res +} + +pub fn cmsgremoteclientappstatusshortcutinfo_unpack(buf []byte) ?CMsgRemoteClientAppStatusShortcutInfo { +mut res := CMsgRemoteClientAppStatusShortcutInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +2 { +res.has_icon = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.icon = v +i = ii +} + +3 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.categories << v +i = ii +} + +4 { +res.has_exepath = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.exepath = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremoteclientappstatusshortcutinfo() CMsgRemoteClientAppStatusShortcutInfo { +return CMsgRemoteClientAppStatusShortcutInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremoteclientappstatusshortcutinfo(o CMsgRemoteClientAppStatusShortcutInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremoteclientappstatusshortcutinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteClientAppStatusShortcutInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremoteclientappstatusshortcutinfo_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteClientAppStatusAppStatus { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +app_state u32 +has_app_state bool +update_info CMsgRemoteClientAppStatusAppUpdateInfo +has_update_info bool +shortcut_info CMsgRemoteClientAppStatusShortcutInfo +has_shortcut_info bool +launch_available bool +has_launch_available bool +} +pub fn (o &CMsgRemoteClientAppStatusAppStatus) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_app_state { +res << vproto.pack_uint32_field(o.app_state, 2) +} + +if o.has_update_info { +res << zzz_vproto_internal_pack_cmsgremoteclientappstatusappupdateinfo(o.update_info, 3) +} + +if o.has_shortcut_info { +res << zzz_vproto_internal_pack_cmsgremoteclientappstatusshortcutinfo(o.shortcut_info, 4) +} + +if o.has_launch_available { +res << vproto.pack_bool_field(o.launch_available, 5) +} + +return res +} + +pub fn cmsgremoteclientappstatusappstatus_unpack(buf []byte) ?CMsgRemoteClientAppStatusAppStatus { +mut res := CMsgRemoteClientAppStatusAppStatus{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_app_state = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_state = v +i = ii +} + +3 { +res.has_update_info = true +ii, v := zzz_vproto_internal_unpack_cmsgremoteclientappstatusappupdateinfo(cur_buf, tag_wiretype.wire_type)? +res.update_info = v +i = ii +} + +4 { +res.has_shortcut_info = true +ii, v := zzz_vproto_internal_unpack_cmsgremoteclientappstatusshortcutinfo(cur_buf, tag_wiretype.wire_type)? +res.shortcut_info = v +i = ii +} + +5 { +res.has_launch_available = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.launch_available = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremoteclientappstatusappstatus() CMsgRemoteClientAppStatusAppStatus { +return CMsgRemoteClientAppStatusAppStatus{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremoteclientappstatusappstatus(o CMsgRemoteClientAppStatusAppStatus, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremoteclientappstatusappstatus(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteClientAppStatusAppStatus) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremoteclientappstatusappstatus_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteClientAppStatus { +mut: +unknown_fields []vproto.UnknownField +pub mut: +status_updates []CMsgRemoteClientAppStatusAppStatus +} +pub fn (o &CMsgRemoteClientAppStatus) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.status_updates { +res << zzz_vproto_internal_pack_cmsgremoteclientappstatusappstatus(x, 1) +} + +return res +} + +pub fn cmsgremoteclientappstatus_unpack(buf []byte) ?CMsgRemoteClientAppStatus { +mut res := CMsgRemoteClientAppStatus{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgremoteclientappstatusappstatus(cur_buf, tag_wiretype.wire_type)? +res.status_updates << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremoteclientappstatus() CMsgRemoteClientAppStatus { +return CMsgRemoteClientAppStatus{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremoteclientappstatus(o CMsgRemoteClientAppStatus, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremoteclientappstatus(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteClientAppStatus) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremoteclientappstatus_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteClientStartStreamReservedGamepad { +mut: +unknown_fields []vproto.UnknownField +pub mut: +controller_type u32 +has_controller_type bool +controller_subtype u32 +has_controller_subtype bool +} +pub fn (o &CMsgRemoteClientStartStreamReservedGamepad) pack() []byte { +mut res := []byte{} +if o.has_controller_type { +res << vproto.pack_uint32_field(o.controller_type, 1) +} + +if o.has_controller_subtype { +res << vproto.pack_uint32_field(o.controller_subtype, 2) +} + +return res +} + +pub fn cmsgremoteclientstartstreamreservedgamepad_unpack(buf []byte) ?CMsgRemoteClientStartStreamReservedGamepad { +mut res := CMsgRemoteClientStartStreamReservedGamepad{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_controller_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.controller_type = v +i = ii +} + +2 { +res.has_controller_subtype = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.controller_subtype = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremoteclientstartstreamreservedgamepad() CMsgRemoteClientStartStreamReservedGamepad { +return CMsgRemoteClientStartStreamReservedGamepad{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremoteclientstartstreamreservedgamepad(o CMsgRemoteClientStartStreamReservedGamepad, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremoteclientstartstreamreservedgamepad(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteClientStartStreamReservedGamepad) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremoteclientstartstreamreservedgamepad_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteClientStartStream { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +environment int +has_environment bool +gamepad_count int +has_gamepad_count bool +launch_option int +has_launch_option bool +lock_parental_lock bool +has_lock_parental_lock bool +unlock_parental_lock string +has_unlock_parental_lock bool +maximum_resolution_x int +has_maximum_resolution_x bool +maximum_resolution_y int +has_maximum_resolution_y bool +gamepads []CMsgRemoteClientStartStreamReservedGamepad +audio_channel_count int +has_audio_channel_count bool +supported_transport []EStreamTransport +} +pub fn (o &CMsgRemoteClientStartStream) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_environment { +res << vproto.pack_int32_field(o.environment, 2) +} + +if o.has_gamepad_count { +res << vproto.pack_int32_field(o.gamepad_count, 3) +} + +if o.has_launch_option { +res << vproto.pack_int32_field(o.launch_option, 4) +} + +if o.has_lock_parental_lock { +res << vproto.pack_bool_field(o.lock_parental_lock, 5) +} + +if o.has_unlock_parental_lock { +res << vproto.pack_string_field(o.unlock_parental_lock, 6) +} + +if o.has_maximum_resolution_x { +res << vproto.pack_int32_field(o.maximum_resolution_x, 7) +} + +if o.has_maximum_resolution_y { +res << vproto.pack_int32_field(o.maximum_resolution_y, 8) +} + +// [packed=false] +for _, x in o.gamepads { +res << zzz_vproto_internal_pack_cmsgremoteclientstartstreamreservedgamepad(x, 9) +} + +if o.has_audio_channel_count { +res << vproto.pack_int32_field(o.audio_channel_count, 10) +} + +// [packed=false] +for _, x in o.supported_transport { +res << zzz_vproto_internal_pack_estreamtransport(x, 11) +} + +return res +} + +pub fn cmsgremoteclientstartstream_unpack(buf []byte) ?CMsgRemoteClientStartStream { +mut res := CMsgRemoteClientStartStream{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_environment = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.environment = v +i = ii +} + +3 { +res.has_gamepad_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.gamepad_count = v +i = ii +} + +4 { +res.has_launch_option = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.launch_option = v +i = ii +} + +5 { +res.has_lock_parental_lock = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.lock_parental_lock = v +i = ii +} + +6 { +res.has_unlock_parental_lock = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.unlock_parental_lock = v +i = ii +} + +7 { +res.has_maximum_resolution_x = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.maximum_resolution_x = v +i = ii +} + +8 { +res.has_maximum_resolution_y = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.maximum_resolution_y = v +i = ii +} + +9 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgremoteclientstartstreamreservedgamepad(cur_buf, tag_wiretype.wire_type)? +res.gamepads << v +i = ii +} + +10 { +res.has_audio_channel_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.audio_channel_count = v +i = ii +} + +11 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_estreamtransport(cur_buf, tag_wiretype.wire_type)? +res.supported_transport << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremoteclientstartstream() CMsgRemoteClientStartStream { +return CMsgRemoteClientStartStream{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremoteclientstartstream(o CMsgRemoteClientStartStream, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremoteclientstartstream(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteClientStartStream) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremoteclientstartstream_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteClientStartStreamResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +e_launch_result int +has_e_launch_result bool +stream_port u32 +has_stream_port bool +launch_options []int +auth_token []byte +has_auth_token bool +transport EStreamTransport +has_transport bool +relay_server string +has_relay_server bool +launch_task string +has_launch_task bool +launch_task_detail string +has_launch_task_detail bool +launch_tasks_done int +has_launch_tasks_done bool +launch_tasks_total int +has_launch_tasks_total bool +} +pub fn (o &CMsgRemoteClientStartStreamResponse) pack() []byte { +mut res := []byte{} +if o.has_e_launch_result { +res << vproto.pack_int32_field(o.e_launch_result, 1) +} + +if o.has_stream_port { +res << vproto.pack_uint32_field(o.stream_port, 2) +} + +// [packed=false] +for _, x in o.launch_options { +res << vproto.pack_int32_field(x, 3) +} + +if o.has_auth_token { +res << vproto.pack_bytes_field(o.auth_token, 4) +} + +if o.has_transport { +res << zzz_vproto_internal_pack_estreamtransport(o.transport, 5) +} + +if o.has_relay_server { +res << vproto.pack_string_field(o.relay_server, 6) +} + +if o.has_launch_task { +res << vproto.pack_string_field(o.launch_task, 7) +} + +if o.has_launch_task_detail { +res << vproto.pack_string_field(o.launch_task_detail, 8) +} + +if o.has_launch_tasks_done { +res << vproto.pack_int32_field(o.launch_tasks_done, 9) +} + +if o.has_launch_tasks_total { +res << vproto.pack_int32_field(o.launch_tasks_total, 10) +} + +return res +} + +pub fn cmsgremoteclientstartstreamresponse_unpack(buf []byte) ?CMsgRemoteClientStartStreamResponse { +mut res := CMsgRemoteClientStartStreamResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_e_launch_result = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.e_launch_result = v +i = ii +} + +2 { +res.has_stream_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.stream_port = v +i = ii +} + +3 { +// [packed=false] +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.launch_options << v +i = ii +} + +4 { +res.has_auth_token = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.auth_token = v +i = ii +} + +5 { +res.has_transport = true +ii, v := zzz_vproto_internal_unpack_estreamtransport(cur_buf, tag_wiretype.wire_type)? +res.transport = v +i = ii +} + +6 { +res.has_relay_server = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.relay_server = v +i = ii +} + +7 { +res.has_launch_task = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.launch_task = v +i = ii +} + +8 { +res.has_launch_task_detail = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.launch_task_detail = v +i = ii +} + +9 { +res.has_launch_tasks_done = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.launch_tasks_done = v +i = ii +} + +10 { +res.has_launch_tasks_total = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.launch_tasks_total = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremoteclientstartstreamresponse() CMsgRemoteClientStartStreamResponse { +return CMsgRemoteClientStartStreamResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremoteclientstartstreamresponse(o CMsgRemoteClientStartStreamResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremoteclientstartstreamresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteClientStartStreamResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremoteclientstartstreamresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteClientPing { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CMsgRemoteClientPing) pack() []byte { +res := []byte{} +return res +} + +pub fn cmsgremoteclientping_unpack(buf []byte) ?CMsgRemoteClientPing { +res := CMsgRemoteClientPing{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremoteclientping() CMsgRemoteClientPing { +return CMsgRemoteClientPing{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremoteclientping(o CMsgRemoteClientPing, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremoteclientping(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteClientPing) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremoteclientping_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteClientPingResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CMsgRemoteClientPingResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cmsgremoteclientpingresponse_unpack(buf []byte) ?CMsgRemoteClientPingResponse { +res := CMsgRemoteClientPingResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremoteclientpingresponse() CMsgRemoteClientPingResponse { +return CMsgRemoteClientPingResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremoteclientpingresponse(o CMsgRemoteClientPingResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremoteclientpingresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteClientPingResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremoteclientpingresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteClientAcceptEUla { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id []u32 +} +pub fn (o &CMsgRemoteClientAcceptEUla) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.app_id { +res << vproto.pack_uint32_field(x, 1) +} + +return res +} + +pub fn cmsgremoteclientaccepteula_unpack(buf []byte) ?CMsgRemoteClientAcceptEUla { +mut res := CMsgRemoteClientAcceptEUla{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremoteclientaccepteula() CMsgRemoteClientAcceptEUla { +return CMsgRemoteClientAcceptEUla{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremoteclientaccepteula(o CMsgRemoteClientAcceptEUla, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremoteclientaccepteula(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteClientAcceptEUla) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremoteclientaccepteula_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteClientGetControllerConfig { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +controller_index u32 +has_controller_index bool +} +pub fn (o &CMsgRemoteClientGetControllerConfig) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_controller_index { +res << vproto.pack_uint32_field(o.controller_index, 3) +} + +return res +} + +pub fn cmsgremoteclientgetcontrollerconfig_unpack(buf []byte) ?CMsgRemoteClientGetControllerConfig { +mut res := CMsgRemoteClientGetControllerConfig{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +3 { +res.has_controller_index = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.controller_index = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremoteclientgetcontrollerconfig() CMsgRemoteClientGetControllerConfig { +return CMsgRemoteClientGetControllerConfig{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremoteclientgetcontrollerconfig(o CMsgRemoteClientGetControllerConfig, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremoteclientgetcontrollerconfig(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteClientGetControllerConfig) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremoteclientgetcontrollerconfig_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteClientGetControllerConfigResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +config_vdf []byte +has_config_vdf bool +} +pub fn (o &CMsgRemoteClientGetControllerConfigResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_config_vdf { +res << vproto.pack_bytes_field(o.config_vdf, 2) +} + +return res +} + +pub fn cmsgremoteclientgetcontrollerconfigresponse_unpack(buf []byte) ?CMsgRemoteClientGetControllerConfigResponse { +mut res := CMsgRemoteClientGetControllerConfigResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_config_vdf = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.config_vdf = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremoteclientgetcontrollerconfigresponse() CMsgRemoteClientGetControllerConfigResponse { +return CMsgRemoteClientGetControllerConfigResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremoteclientgetcontrollerconfigresponse(o CMsgRemoteClientGetControllerConfigResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremoteclientgetcontrollerconfigresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteClientGetControllerConfigResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremoteclientgetcontrollerconfigresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgRemoteClientStreamingEnabled { +mut: +unknown_fields []vproto.UnknownField +pub mut: +enabled bool +} +pub fn (o &CMsgRemoteClientStreamingEnabled) pack() []byte { +mut res := []byte{} +res << vproto.pack_bool_field(o.enabled, 1) + +return res +} + +pub fn cmsgremoteclientstreamingenabled_unpack(buf []byte) ?CMsgRemoteClientStreamingEnabled { +mut res := CMsgRemoteClientStreamingEnabled{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enabled = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgremoteclientstreamingenabled() CMsgRemoteClientStreamingEnabled { +return CMsgRemoteClientStreamingEnabled{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgremoteclientstreamingenabled(o CMsgRemoteClientStreamingEnabled, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgremoteclientstreamingenabled(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgRemoteClientStreamingEnabled) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgremoteclientstreamingenabled_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_remoteclient_service.steamclient_pb.v b/proto/steammessages_remoteclient_service.steamclient_pb.v new file mode 100644 index 0000000..7caab2f --- /dev/null +++ b/proto/steammessages_remoteclient_service.steamclient_pb.v @@ -0,0 +1,7 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + diff --git a/proto/steammessages_remoteclient_service_messages_pb.v b/proto/steammessages_remoteclient_service_messages_pb.v new file mode 100644 index 0000000..f57c68e --- /dev/null +++ b/proto/steammessages_remoteclient_service_messages_pb.v @@ -0,0 +1,2075 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CRemoteClientCreateSessionRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CRemoteClientCreateSessionRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn cremoteclientcreatesessionrequest_unpack(buf []byte) ?CRemoteClientCreateSessionRequest { +res := CRemoteClientCreateSessionRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteclientcreatesessionrequest() CRemoteClientCreateSessionRequest { +return CRemoteClientCreateSessionRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteclientcreatesessionrequest(o CRemoteClientCreateSessionRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteclientcreatesessionrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemoteClientCreateSessionRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteclientcreatesessionrequest_unpack(v)? +return i, unpacked +} +pub struct CRemoteClientCreateSessionResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +session_id u64 +has_session_id bool +euniverse int +has_euniverse bool +} +pub fn (o &CRemoteClientCreateSessionResponse) pack() []byte { +mut res := []byte{} +if o.has_session_id { +res << vproto.pack_64bit_field(o.session_id, 1) +} + +if o.has_euniverse { +res << vproto.pack_int32_field(o.euniverse, 2) +} + +return res +} + +pub fn cremoteclientcreatesessionresponse_unpack(buf []byte) ?CRemoteClientCreateSessionResponse { +mut res := CRemoteClientCreateSessionResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_session_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.session_id = v +i = ii +} + +2 { +res.has_euniverse = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.euniverse = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteclientcreatesessionresponse() CRemoteClientCreateSessionResponse { +return CRemoteClientCreateSessionResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteclientcreatesessionresponse(o CRemoteClientCreateSessionResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteclientcreatesessionresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemoteClientCreateSessionResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteclientcreatesessionresponse_unpack(v)? +return i, unpacked +} +pub struct CRemoteClientStartPairingRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +session_id u64 +has_session_id bool +} +pub fn (o &CRemoteClientStartPairingRequest) pack() []byte { +mut res := []byte{} +if o.has_session_id { +res << vproto.pack_64bit_field(o.session_id, 1) +} + +return res +} + +pub fn cremoteclientstartpairingrequest_unpack(buf []byte) ?CRemoteClientStartPairingRequest { +mut res := CRemoteClientStartPairingRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_session_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.session_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteclientstartpairingrequest() CRemoteClientStartPairingRequest { +return CRemoteClientStartPairingRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteclientstartpairingrequest(o CRemoteClientStartPairingRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteclientstartpairingrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemoteClientStartPairingRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteclientstartpairingrequest_unpack(v)? +return i, unpacked +} +pub struct CRemoteClientStartPairingResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +pin u32 +has_pin bool +} +pub fn (o &CRemoteClientStartPairingResponse) pack() []byte { +mut res := []byte{} +if o.has_pin { +res << vproto.pack_uint32_field(o.pin, 1) +} + +return res +} + +pub fn cremoteclientstartpairingresponse_unpack(buf []byte) ?CRemoteClientStartPairingResponse { +mut res := CRemoteClientStartPairingResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_pin = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.pin = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteclientstartpairingresponse() CRemoteClientStartPairingResponse { +return CRemoteClientStartPairingResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteclientstartpairingresponse(o CRemoteClientStartPairingResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteclientstartpairingresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemoteClientStartPairingResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteclientstartpairingresponse_unpack(v)? +return i, unpacked +} +pub struct CRemoteClientSetPairingInfoRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +session_id u64 +has_session_id bool +device_id u64 +has_device_id bool +request []byte +has_request bool +} +pub fn (o &CRemoteClientSetPairingInfoRequest) pack() []byte { +mut res := []byte{} +if o.has_session_id { +res << vproto.pack_64bit_field(o.session_id, 1) +} + +if o.has_device_id { +res << vproto.pack_64bit_field(o.device_id, 2) +} + +if o.has_request { +res << vproto.pack_bytes_field(o.request, 3) +} + +return res +} + +pub fn cremoteclientsetpairinginforequest_unpack(buf []byte) ?CRemoteClientSetPairingInfoRequest { +mut res := CRemoteClientSetPairingInfoRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_session_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.session_id = v +i = ii +} + +2 { +res.has_device_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.device_id = v +i = ii +} + +3 { +res.has_request = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.request = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteclientsetpairinginforequest() CRemoteClientSetPairingInfoRequest { +return CRemoteClientSetPairingInfoRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteclientsetpairinginforequest(o CRemoteClientSetPairingInfoRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteclientsetpairinginforequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemoteClientSetPairingInfoRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteclientsetpairinginforequest_unpack(v)? +return i, unpacked +} +pub struct CRemoteClientSetPairingInfoResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CRemoteClientSetPairingInfoResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cremoteclientsetpairinginforesponse_unpack(buf []byte) ?CRemoteClientSetPairingInfoResponse { +res := CRemoteClientSetPairingInfoResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteclientsetpairinginforesponse() CRemoteClientSetPairingInfoResponse { +return CRemoteClientSetPairingInfoResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteclientsetpairinginforesponse(o CRemoteClientSetPairingInfoResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteclientsetpairinginforesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemoteClientSetPairingInfoResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteclientsetpairinginforesponse_unpack(v)? +return i, unpacked +} +pub struct CRemoteClientGetPairingInfoRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +pin u32 +has_pin bool +} +pub fn (o &CRemoteClientGetPairingInfoRequest) pack() []byte { +mut res := []byte{} +if o.has_pin { +res << vproto.pack_uint32_field(o.pin, 1) +} + +return res +} + +pub fn cremoteclientgetpairinginforequest_unpack(buf []byte) ?CRemoteClientGetPairingInfoRequest { +mut res := CRemoteClientGetPairingInfoRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_pin = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.pin = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteclientgetpairinginforequest() CRemoteClientGetPairingInfoRequest { +return CRemoteClientGetPairingInfoRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteclientgetpairinginforequest(o CRemoteClientGetPairingInfoRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteclientgetpairinginforequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemoteClientGetPairingInfoRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteclientgetpairinginforequest_unpack(v)? +return i, unpacked +} +pub struct CRemoteClientGetPairingInfoResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +session_id u64 +has_session_id bool +device_id u64 +has_device_id bool +request []byte +has_request bool +} +pub fn (o &CRemoteClientGetPairingInfoResponse) pack() []byte { +mut res := []byte{} +if o.has_session_id { +res << vproto.pack_64bit_field(o.session_id, 1) +} + +if o.has_device_id { +res << vproto.pack_64bit_field(o.device_id, 2) +} + +if o.has_request { +res << vproto.pack_bytes_field(o.request, 3) +} + +return res +} + +pub fn cremoteclientgetpairinginforesponse_unpack(buf []byte) ?CRemoteClientGetPairingInfoResponse { +mut res := CRemoteClientGetPairingInfoResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_session_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.session_id = v +i = ii +} + +2 { +res.has_device_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.device_id = v +i = ii +} + +3 { +res.has_request = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.request = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteclientgetpairinginforesponse() CRemoteClientGetPairingInfoResponse { +return CRemoteClientGetPairingInfoResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteclientgetpairinginforesponse(o CRemoteClientGetPairingInfoResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteclientgetpairinginforesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemoteClientGetPairingInfoResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteclientgetpairinginforesponse_unpack(v)? +return i, unpacked +} +pub struct CRemoteClientCancelPairingRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +session_id u64 +has_session_id bool +} +pub fn (o &CRemoteClientCancelPairingRequest) pack() []byte { +mut res := []byte{} +if o.has_session_id { +res << vproto.pack_64bit_field(o.session_id, 1) +} + +return res +} + +pub fn cremoteclientcancelpairingrequest_unpack(buf []byte) ?CRemoteClientCancelPairingRequest { +mut res := CRemoteClientCancelPairingRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_session_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.session_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteclientcancelpairingrequest() CRemoteClientCancelPairingRequest { +return CRemoteClientCancelPairingRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteclientcancelpairingrequest(o CRemoteClientCancelPairingRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteclientcancelpairingrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemoteClientCancelPairingRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteclientcancelpairingrequest_unpack(v)? +return i, unpacked +} +pub struct CRemoteClientCancelPairingResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CRemoteClientCancelPairingResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cremoteclientcancelpairingresponse_unpack(buf []byte) ?CRemoteClientCancelPairingResponse { +res := CRemoteClientCancelPairingResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteclientcancelpairingresponse() CRemoteClientCancelPairingResponse { +return CRemoteClientCancelPairingResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteclientcancelpairingresponse(o CRemoteClientCancelPairingResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteclientcancelpairingresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemoteClientCancelPairingResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteclientcancelpairingresponse_unpack(v)? +return i, unpacked +} +pub struct CRemoteClientRegisterStatusUpdateNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +session_id u64 +has_session_id bool +steamid u64 +has_steamid bool +device_id u64 +has_device_id bool +} +pub fn (o &CRemoteClientRegisterStatusUpdateNotification) pack() []byte { +mut res := []byte{} +if o.has_session_id { +res << vproto.pack_64bit_field(o.session_id, 1) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 2) +} + +if o.has_device_id { +res << vproto.pack_64bit_field(o.device_id, 3) +} + +return res +} + +pub fn cremoteclientregisterstatusupdatenotification_unpack(buf []byte) ?CRemoteClientRegisterStatusUpdateNotification { +mut res := CRemoteClientRegisterStatusUpdateNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_session_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.session_id = v +i = ii +} + +2 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +3 { +res.has_device_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.device_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteclientregisterstatusupdatenotification() CRemoteClientRegisterStatusUpdateNotification { +return CRemoteClientRegisterStatusUpdateNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteclientregisterstatusupdatenotification(o CRemoteClientRegisterStatusUpdateNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteclientregisterstatusupdatenotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemoteClientRegisterStatusUpdateNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteclientregisterstatusupdatenotification_unpack(v)? +return i, unpacked +} +pub struct CRemoteClientUnregisterStatusUpdateNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +session_id u64 +has_session_id bool +steamid u64 +has_steamid bool +} +pub fn (o &CRemoteClientUnregisterStatusUpdateNotification) pack() []byte { +mut res := []byte{} +if o.has_session_id { +res << vproto.pack_64bit_field(o.session_id, 1) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 2) +} + +return res +} + +pub fn cremoteclientunregisterstatusupdatenotification_unpack(buf []byte) ?CRemoteClientUnregisterStatusUpdateNotification { +mut res := CRemoteClientUnregisterStatusUpdateNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_session_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.session_id = v +i = ii +} + +2 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteclientunregisterstatusupdatenotification() CRemoteClientUnregisterStatusUpdateNotification { +return CRemoteClientUnregisterStatusUpdateNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteclientunregisterstatusupdatenotification(o CRemoteClientUnregisterStatusUpdateNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteclientunregisterstatusupdatenotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemoteClientUnregisterStatusUpdateNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteclientunregisterstatusupdatenotification_unpack(v)? +return i, unpacked +} +pub struct CRemoteClientOnlineNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +} +pub fn (o &CRemoteClientOnlineNotification) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +return res +} + +pub fn cremoteclientonlinenotification_unpack(buf []byte) ?CRemoteClientOnlineNotification { +mut res := CRemoteClientOnlineNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteclientonlinenotification() CRemoteClientOnlineNotification { +return CRemoteClientOnlineNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteclientonlinenotification(o CRemoteClientOnlineNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteclientonlinenotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemoteClientOnlineNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteclientonlinenotification_unpack(v)? +return i, unpacked +} +pub struct CRemoteClientRemotePacketNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +session_id u64 +has_session_id bool +steamid u64 +has_steamid bool +payload []byte +has_payload bool +} +pub fn (o &CRemoteClientRemotePacketNotification) pack() []byte { +mut res := []byte{} +if o.has_session_id { +res << vproto.pack_64bit_field(o.session_id, 1) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 2) +} + +if o.has_payload { +res << vproto.pack_bytes_field(o.payload, 4) +} + +return res +} + +pub fn cremoteclientremotepacketnotification_unpack(buf []byte) ?CRemoteClientRemotePacketNotification { +mut res := CRemoteClientRemotePacketNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_session_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.session_id = v +i = ii +} + +2 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +4 { +res.has_payload = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.payload = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteclientremotepacketnotification() CRemoteClientRemotePacketNotification { +return CRemoteClientRemotePacketNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteclientremotepacketnotification(o CRemoteClientRemotePacketNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteclientremotepacketnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemoteClientRemotePacketNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteclientremotepacketnotification_unpack(v)? +return i, unpacked +} +pub struct CRemoteClientReplyPacketNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +session_id u64 +has_session_id bool +payload []byte +has_payload bool +} +pub fn (o &CRemoteClientReplyPacketNotification) pack() []byte { +mut res := []byte{} +if o.has_session_id { +res << vproto.pack_64bit_field(o.session_id, 1) +} + +if o.has_payload { +res << vproto.pack_bytes_field(o.payload, 2) +} + +return res +} + +pub fn cremoteclientreplypacketnotification_unpack(buf []byte) ?CRemoteClientReplyPacketNotification { +mut res := CRemoteClientReplyPacketNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_session_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.session_id = v +i = ii +} + +2 { +res.has_payload = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.payload = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteclientreplypacketnotification() CRemoteClientReplyPacketNotification { +return CRemoteClientReplyPacketNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteclientreplypacketnotification(o CRemoteClientReplyPacketNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteclientreplypacketnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemoteClientReplyPacketNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteclientreplypacketnotification_unpack(v)? +return i, unpacked +} +pub struct CRemoteClientGetRepliesRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +session_id u64 +has_session_id bool +} +pub fn (o &CRemoteClientGetRepliesRequest) pack() []byte { +mut res := []byte{} +if o.has_session_id { +res << vproto.pack_64bit_field(o.session_id, 1) +} + +return res +} + +pub fn cremoteclientgetrepliesrequest_unpack(buf []byte) ?CRemoteClientGetRepliesRequest { +mut res := CRemoteClientGetRepliesRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_session_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.session_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteclientgetrepliesrequest() CRemoteClientGetRepliesRequest { +return CRemoteClientGetRepliesRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteclientgetrepliesrequest(o CRemoteClientGetRepliesRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteclientgetrepliesrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemoteClientGetRepliesRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteclientgetrepliesrequest_unpack(v)? +return i, unpacked +} +pub struct CRemoteClientGetRepliesResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +payload [][]byte +} +pub fn (o &CRemoteClientGetRepliesResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.payload { +res << vproto.pack_bytes_field(x, 1) +} + +return res +} + +pub fn cremoteclientgetrepliesresponse_unpack(buf []byte) ?CRemoteClientGetRepliesResponse { +mut res := CRemoteClientGetRepliesResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.payload << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteclientgetrepliesresponse() CRemoteClientGetRepliesResponse { +return CRemoteClientGetRepliesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteclientgetrepliesresponse(o CRemoteClientGetRepliesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteclientgetrepliesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemoteClientGetRepliesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteclientgetrepliesresponse_unpack(v)? +return i, unpacked +} +pub struct CRemoteClientAllocateTUrnserverRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +cellid u32 +has_cellid bool +credentials string +has_credentials bool +} +pub fn (o &CRemoteClientAllocateTUrnserverRequest) pack() []byte { +mut res := []byte{} +if o.has_cellid { +res << vproto.pack_uint32_field(o.cellid, 1) +} + +if o.has_credentials { +res << vproto.pack_string_field(o.credentials, 2) +} + +return res +} + +pub fn cremoteclientallocateturnserverrequest_unpack(buf []byte) ?CRemoteClientAllocateTUrnserverRequest { +mut res := CRemoteClientAllocateTUrnserverRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_cellid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cellid = v +i = ii +} + +2 { +res.has_credentials = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.credentials = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteclientallocateturnserverrequest() CRemoteClientAllocateTUrnserverRequest { +return CRemoteClientAllocateTUrnserverRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteclientallocateturnserverrequest(o CRemoteClientAllocateTUrnserverRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteclientallocateturnserverrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemoteClientAllocateTUrnserverRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteclientallocateturnserverrequest_unpack(v)? +return i, unpacked +} +pub struct CRemoteClientAllocateTUrnserverResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +turn_server string +has_turn_server bool +} +pub fn (o &CRemoteClientAllocateTUrnserverResponse) pack() []byte { +mut res := []byte{} +if o.has_turn_server { +res << vproto.pack_string_field(o.turn_server, 1) +} + +return res +} + +pub fn cremoteclientallocateturnserverresponse_unpack(buf []byte) ?CRemoteClientAllocateTUrnserverResponse { +mut res := CRemoteClientAllocateTUrnserverResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_turn_server = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.turn_server = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteclientallocateturnserverresponse() CRemoteClientAllocateTUrnserverResponse { +return CRemoteClientAllocateTUrnserverResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteclientallocateturnserverresponse(o CRemoteClientAllocateTUrnserverResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteclientallocateturnserverresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemoteClientAllocateTUrnserverResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteclientallocateturnserverresponse_unpack(v)? +return i, unpacked +} +pub struct CRemoteClientAllocateRelayServerRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +cellid u32 +has_cellid bool +credentials string +has_credentials bool +} +pub fn (o &CRemoteClientAllocateRelayServerRequest) pack() []byte { +mut res := []byte{} +if o.has_cellid { +res << vproto.pack_uint32_field(o.cellid, 1) +} + +if o.has_credentials { +res << vproto.pack_string_field(o.credentials, 2) +} + +return res +} + +pub fn cremoteclientallocaterelayserverrequest_unpack(buf []byte) ?CRemoteClientAllocateRelayServerRequest { +mut res := CRemoteClientAllocateRelayServerRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_cellid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.cellid = v +i = ii +} + +2 { +res.has_credentials = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.credentials = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteclientallocaterelayserverrequest() CRemoteClientAllocateRelayServerRequest { +return CRemoteClientAllocateRelayServerRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteclientallocaterelayserverrequest(o CRemoteClientAllocateRelayServerRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteclientallocaterelayserverrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemoteClientAllocateRelayServerRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteclientallocaterelayserverrequest_unpack(v)? +return i, unpacked +} +pub struct CRemoteClientAllocateRelayServerResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +relay_server string +has_relay_server bool +} +pub fn (o &CRemoteClientAllocateRelayServerResponse) pack() []byte { +mut res := []byte{} +if o.has_relay_server { +res << vproto.pack_string_field(o.relay_server, 1) +} + +return res +} + +pub fn cremoteclientallocaterelayserverresponse_unpack(buf []byte) ?CRemoteClientAllocateRelayServerResponse { +mut res := CRemoteClientAllocateRelayServerResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_relay_server = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.relay_server = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteclientallocaterelayserverresponse() CRemoteClientAllocateRelayServerResponse { +return CRemoteClientAllocateRelayServerResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteclientallocaterelayserverresponse(o CRemoteClientAllocateRelayServerResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteclientallocaterelayserverresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemoteClientAllocateRelayServerResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteclientallocaterelayserverresponse_unpack(v)? +return i, unpacked +} +pub struct CRemoteClientAllocateSDrrequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +} +pub fn (o &CRemoteClientAllocateSDrrequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +return res +} + +pub fn cremoteclientallocatesdrrequest_unpack(buf []byte) ?CRemoteClientAllocateSDrrequest { +mut res := CRemoteClientAllocateSDrrequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteclientallocatesdrrequest() CRemoteClientAllocateSDrrequest { +return CRemoteClientAllocateSDrrequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteclientallocatesdrrequest(o CRemoteClientAllocateSDrrequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteclientallocatesdrrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemoteClientAllocateSDrrequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteclientallocatesdrrequest_unpack(v)? +return i, unpacked +} +pub struct CRemoteClientAllocateSDrresponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CRemoteClientAllocateSDrresponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cremoteclientallocatesdrresponse_unpack(buf []byte) ?CRemoteClientAllocateSDrresponse { +res := CRemoteClientAllocateSDrresponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteclientallocatesdrresponse() CRemoteClientAllocateSDrresponse { +return CRemoteClientAllocateSDrresponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteclientallocatesdrresponse(o CRemoteClientAllocateSDrresponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteclientallocatesdrresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemoteClientAllocateSDrresponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteclientallocatesdrresponse_unpack(v)? +return i, unpacked +} +pub struct CRemoteClientSteamBroadcastNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +clientid u64 +has_clientid bool +payload []byte +has_payload bool +} +pub fn (o &CRemoteClientSteamBroadcastNotification) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_clientid { +res << vproto.pack_64bit_field(o.clientid, 2) +} + +if o.has_payload { +res << vproto.pack_bytes_field(o.payload, 3) +} + +return res +} + +pub fn cremoteclientsteambroadcastnotification_unpack(buf []byte) ?CRemoteClientSteamBroadcastNotification { +mut res := CRemoteClientSteamBroadcastNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_clientid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.clientid = v +i = ii +} + +3 { +res.has_payload = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.payload = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteclientsteambroadcastnotification() CRemoteClientSteamBroadcastNotification { +return CRemoteClientSteamBroadcastNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteclientsteambroadcastnotification(o CRemoteClientSteamBroadcastNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteclientsteambroadcastnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemoteClientSteamBroadcastNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteclientsteambroadcastnotification_unpack(v)? +return i, unpacked +} +pub struct CRemoteClientSteamToSteamNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +src_clientid u64 +has_src_clientid bool +dst_clientid u64 +has_dst_clientid bool +secretid u32 +has_secretid bool +encrypted_payload []byte +has_encrypted_payload bool +} +pub fn (o &CRemoteClientSteamToSteamNotification) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_src_clientid { +res << vproto.pack_64bit_field(o.src_clientid, 2) +} + +if o.has_dst_clientid { +res << vproto.pack_64bit_field(o.dst_clientid, 3) +} + +if o.has_secretid { +res << vproto.pack_uint32_field(o.secretid, 4) +} + +if o.has_encrypted_payload { +res << vproto.pack_bytes_field(o.encrypted_payload, 5) +} + +return res +} + +pub fn cremoteclientsteamtosteamnotification_unpack(buf []byte) ?CRemoteClientSteamToSteamNotification { +mut res := CRemoteClientSteamToSteamNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_src_clientid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.src_clientid = v +i = ii +} + +3 { +res.has_dst_clientid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.dst_clientid = v +i = ii +} + +4 { +res.has_secretid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.secretid = v +i = ii +} + +5 { +res.has_encrypted_payload = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.encrypted_payload = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteclientsteamtosteamnotification() CRemoteClientSteamToSteamNotification { +return CRemoteClientSteamToSteamNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteclientsteamtosteamnotification(o CRemoteClientSteamToSteamNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteclientsteamtosteamnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemoteClientSteamToSteamNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteclientsteamtosteamnotification_unpack(v)? +return i, unpacked +} +pub struct CRemotePlaySessionStartedRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +host_account_id u32 +has_host_account_id bool +client_account_id u32 +has_client_account_id bool +appid u32 +has_appid bool +device_form_factor int +has_device_form_factor bool +} +pub fn (o &CRemotePlaySessionStartedRequest) pack() []byte { +mut res := []byte{} +if o.has_host_account_id { +res << vproto.pack_uint32_field(o.host_account_id, 1) +} + +if o.has_client_account_id { +res << vproto.pack_uint32_field(o.client_account_id, 2) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 3) +} + +if o.has_device_form_factor { +res << vproto.pack_int32_field(o.device_form_factor, 4) +} + +return res +} + +pub fn cremoteplaysessionstartedrequest_unpack(buf []byte) ?CRemotePlaySessionStartedRequest { +mut res := CRemotePlaySessionStartedRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_host_account_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.host_account_id = v +i = ii +} + +2 { +res.has_client_account_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.client_account_id = v +i = ii +} + +3 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +4 { +res.has_device_form_factor = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.device_form_factor = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteplaysessionstartedrequest() CRemotePlaySessionStartedRequest { +return CRemotePlaySessionStartedRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteplaysessionstartedrequest(o CRemotePlaySessionStartedRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteplaysessionstartedrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemotePlaySessionStartedRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteplaysessionstartedrequest_unpack(v)? +return i, unpacked +} +pub struct CRemotePlaySessionStartedResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +record_id u64 +has_record_id bool +} +pub fn (o &CRemotePlaySessionStartedResponse) pack() []byte { +mut res := []byte{} +if o.has_record_id { +res << vproto.pack_64bit_field(o.record_id, 1) +} + +return res +} + +pub fn cremoteplaysessionstartedresponse_unpack(buf []byte) ?CRemotePlaySessionStartedResponse { +mut res := CRemotePlaySessionStartedResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_record_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.record_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteplaysessionstartedresponse() CRemotePlaySessionStartedResponse { +return CRemotePlaySessionStartedResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteplaysessionstartedresponse(o CRemotePlaySessionStartedResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteplaysessionstartedresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemotePlaySessionStartedResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteplaysessionstartedresponse_unpack(v)? +return i, unpacked +} +pub struct CRemotePlaySessionStoppedNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +record_id u64 +has_record_id bool +used_x264 bool +has_used_x264 bool +used_h264 bool +has_used_h264 bool +used_hevc bool +has_used_hevc bool +} +pub fn (o &CRemotePlaySessionStoppedNotification) pack() []byte { +mut res := []byte{} +if o.has_record_id { +res << vproto.pack_64bit_field(o.record_id, 1) +} + +if o.has_used_x264 { +res << vproto.pack_bool_field(o.used_x264, 2) +} + +if o.has_used_h264 { +res << vproto.pack_bool_field(o.used_h264, 3) +} + +if o.has_used_hevc { +res << vproto.pack_bool_field(o.used_hevc, 4) +} + +return res +} + +pub fn cremoteplaysessionstoppednotification_unpack(buf []byte) ?CRemotePlaySessionStoppedNotification { +mut res := CRemotePlaySessionStoppedNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_record_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.record_id = v +i = ii +} + +2 { +res.has_used_x264 = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.used_x264 = v +i = ii +} + +3 { +res.has_used_h264 = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.used_h264 = v +i = ii +} + +4 { +res.has_used_hevc = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.used_hevc = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteplaysessionstoppednotification() CRemotePlaySessionStoppedNotification { +return CRemotePlaySessionStoppedNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteplaysessionstoppednotification(o CRemotePlaySessionStoppedNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteplaysessionstoppednotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemotePlaySessionStoppedNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteplaysessionstoppednotification_unpack(v)? +return i, unpacked +} +pub struct CRemotePlayTogetherNotificationControllerSlots { +mut: +unknown_fields []vproto.UnknownField +pub mut: +slotid u32 +has_slotid bool +steamid u64 +has_steamid bool +} +pub fn (o &CRemotePlayTogetherNotificationControllerSlots) pack() []byte { +mut res := []byte{} +if o.has_slotid { +res << vproto.pack_uint32_field(o.slotid, 1) +} + +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 2) +} + +return res +} + +pub fn cremoteplaytogethernotificationcontrollerslots_unpack(buf []byte) ?CRemotePlayTogetherNotificationControllerSlots { +mut res := CRemotePlayTogetherNotificationControllerSlots{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_slotid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.slotid = v +i = ii +} + +2 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteplaytogethernotificationcontrollerslots() CRemotePlayTogetherNotificationControllerSlots { +return CRemotePlayTogetherNotificationControllerSlots{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteplaytogethernotificationcontrollerslots(o CRemotePlayTogetherNotificationControllerSlots, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteplaytogethernotificationcontrollerslots(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemotePlayTogetherNotificationControllerSlots) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteplaytogethernotificationcontrollerslots_unpack(v)? +return i, unpacked +} +pub struct CRemotePlayTogetherNotificationGroupUpdated { +mut: +unknown_fields []vproto.UnknownField +pub mut: +host_steamid u64 +has_host_steamid bool +host_clientid u64 +has_host_clientid bool +players []u64 +host_gameid u64 +has_host_gameid bool +controller_slots []CRemotePlayTogetherNotificationControllerSlots +} +pub fn (o &CRemotePlayTogetherNotificationGroupUpdated) pack() []byte { +mut res := []byte{} +if o.has_host_steamid { +res << vproto.pack_64bit_field(o.host_steamid, 1) +} + +if o.has_host_clientid { +res << vproto.pack_64bit_field(o.host_clientid, 2) +} + +// [packed=false] +for _, x in o.players { +res << vproto.pack_64bit_field(x, 3) +} + +if o.has_host_gameid { +res << vproto.pack_64bit_field(o.host_gameid, 4) +} + +// [packed=false] +for _, x in o.controller_slots { +res << zzz_vproto_internal_pack_cremoteplaytogethernotificationcontrollerslots(x, 5) +} + +return res +} + +pub fn cremoteplaytogethernotificationgroupupdated_unpack(buf []byte) ?CRemotePlayTogetherNotificationGroupUpdated { +mut res := CRemotePlayTogetherNotificationGroupUpdated{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_host_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.host_steamid = v +i = ii +} + +2 { +res.has_host_clientid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.host_clientid = v +i = ii +} + +3 { +// [packed=false] +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.players << v +i = ii +} + +4 { +res.has_host_gameid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.host_gameid = v +i = ii +} + +5 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cremoteplaytogethernotificationcontrollerslots(cur_buf, tag_wiretype.wire_type)? +res.controller_slots << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteplaytogethernotificationgroupupdated() CRemotePlayTogetherNotificationGroupUpdated { +return CRemotePlayTogetherNotificationGroupUpdated{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteplaytogethernotificationgroupupdated(o CRemotePlayTogetherNotificationGroupUpdated, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteplaytogethernotificationgroupupdated(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemotePlayTogetherNotificationGroupUpdated) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteplaytogethernotificationgroupupdated_unpack(v)? +return i, unpacked +} +pub struct CRemotePlayTogetherNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +} +pub fn (o &CRemotePlayTogetherNotification) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +return res +} + +pub fn cremoteplaytogethernotification_unpack(buf []byte) ?CRemotePlayTogetherNotification { +mut res := CRemotePlayTogetherNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremoteplaytogethernotification() CRemotePlayTogetherNotification { +return CRemotePlayTogetherNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremoteplaytogethernotification(o CRemotePlayTogetherNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremoteplaytogethernotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemotePlayTogetherNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremoteplaytogethernotification_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_secrets.steamclient_pb.v b/proto/steammessages_secrets.steamclient_pb.v new file mode 100644 index 0000000..f37c690 --- /dev/null +++ b/proto/steammessages_secrets.steamclient_pb.v @@ -0,0 +1,337 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +[_allow_multiple_values] +enum EKeyEscrowUsage { +k_ekeyescrowusagestreamingdevice = 0 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_ekeyescrowusage(e EKeyEscrowUsage, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_ekeyescrowusage(buf []byte, tag_wiretype vproto.WireType) ?(int, EKeyEscrowUsage) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EKeyEscrowUsage(v) +} +pub struct CKeyEscrowRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +rsa_oaep_sha_ticket []byte +has_rsa_oaep_sha_ticket bool +password []byte +has_password bool +usage EKeyEscrowUsage +has_usage bool +device_name string +has_device_name bool +} +pub fn (o &CKeyEscrowRequest) pack() []byte { +mut res := []byte{} +if o.has_rsa_oaep_sha_ticket { +res << vproto.pack_bytes_field(o.rsa_oaep_sha_ticket, 1) +} + +if o.has_password { +res << vproto.pack_bytes_field(o.password, 2) +} + +if o.has_usage { +res << zzz_vproto_internal_pack_ekeyescrowusage(o.usage, 3) +} + +if o.has_device_name { +res << vproto.pack_string_field(o.device_name, 4) +} + +return res +} + +pub fn ckeyescrowrequest_unpack(buf []byte) ?CKeyEscrowRequest { +mut res := CKeyEscrowRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_rsa_oaep_sha_ticket = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.rsa_oaep_sha_ticket = v +i = ii +} + +2 { +res.has_password = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.password = v +i = ii +} + +3 { +res.has_usage = true +ii, v := zzz_vproto_internal_unpack_ekeyescrowusage(cur_buf, tag_wiretype.wire_type)? +res.usage = v +i = ii +} + +4 { +res.has_device_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.device_name = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ckeyescrowrequest() CKeyEscrowRequest { +return CKeyEscrowRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ckeyescrowrequest(o CKeyEscrowRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ckeyescrowrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CKeyEscrowRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ckeyescrowrequest_unpack(v)? +return i, unpacked +} +pub struct CKeyEscrowTicket { +mut: +unknown_fields []vproto.UnknownField +pub mut: +password []byte +has_password bool +identifier u64 +has_identifier bool +payload []byte +has_payload bool +timestamp u32 +has_timestamp bool +usage EKeyEscrowUsage +has_usage bool +device_name string +has_device_name bool +device_model string +has_device_model bool +device_serial string +has_device_serial bool +device_provisioning_id u32 +has_device_provisioning_id bool +} +pub fn (o &CKeyEscrowTicket) pack() []byte { +mut res := []byte{} +if o.has_password { +res << vproto.pack_bytes_field(o.password, 1) +} + +if o.has_identifier { +res << vproto.pack_uint64_field(o.identifier, 2) +} + +if o.has_payload { +res << vproto.pack_bytes_field(o.payload, 3) +} + +if o.has_timestamp { +res << vproto.pack_uint32_field(o.timestamp, 4) +} + +if o.has_usage { +res << zzz_vproto_internal_pack_ekeyescrowusage(o.usage, 5) +} + +if o.has_device_name { +res << vproto.pack_string_field(o.device_name, 6) +} + +if o.has_device_model { +res << vproto.pack_string_field(o.device_model, 7) +} + +if o.has_device_serial { +res << vproto.pack_string_field(o.device_serial, 8) +} + +if o.has_device_provisioning_id { +res << vproto.pack_uint32_field(o.device_provisioning_id, 9) +} + +return res +} + +pub fn ckeyescrowticket_unpack(buf []byte) ?CKeyEscrowTicket { +mut res := CKeyEscrowTicket{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_password = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.password = v +i = ii +} + +2 { +res.has_identifier = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.identifier = v +i = ii +} + +3 { +res.has_payload = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.payload = v +i = ii +} + +4 { +res.has_timestamp = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp = v +i = ii +} + +5 { +res.has_usage = true +ii, v := zzz_vproto_internal_unpack_ekeyescrowusage(cur_buf, tag_wiretype.wire_type)? +res.usage = v +i = ii +} + +6 { +res.has_device_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.device_name = v +i = ii +} + +7 { +res.has_device_model = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.device_model = v +i = ii +} + +8 { +res.has_device_serial = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.device_serial = v +i = ii +} + +9 { +res.has_device_provisioning_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.device_provisioning_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ckeyescrowticket() CKeyEscrowTicket { +return CKeyEscrowTicket{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ckeyescrowticket(o CKeyEscrowTicket, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ckeyescrowticket(buf []byte, tag_wiretype vproto.WireType) ?(int, CKeyEscrowTicket) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ckeyescrowticket_unpack(v)? +return i, unpacked +} +pub struct CKeyEscrowResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +ticket CKeyEscrowTicket +has_ticket bool +} +pub fn (o &CKeyEscrowResponse) pack() []byte { +mut res := []byte{} +if o.has_ticket { +res << zzz_vproto_internal_pack_ckeyescrowticket(o.ticket, 1) +} + +return res +} + +pub fn ckeyescrowresponse_unpack(buf []byte) ?CKeyEscrowResponse { +mut res := CKeyEscrowResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_ticket = true +ii, v := zzz_vproto_internal_unpack_ckeyescrowticket(cur_buf, tag_wiretype.wire_type)? +res.ticket = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ckeyescrowresponse() CKeyEscrowResponse { +return CKeyEscrowResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ckeyescrowresponse(o CKeyEscrowResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ckeyescrowresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CKeyEscrowResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ckeyescrowresponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_shader.steamclient_pb.v b/proto/steammessages_shader.steamclient_pb.v new file mode 100644 index 0000000..d29ce5d --- /dev/null +++ b/proto/steammessages_shader.steamclient_pb.v @@ -0,0 +1,571 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CShaderRegisterShaderRequestShader { +mut: +unknown_fields []vproto.UnknownField +pub mut: +cache_key_sha []byte +has_cache_key_sha bool +shader_code_sha []byte +has_shader_code_sha bool +} +pub fn (o &CShaderRegisterShaderRequestShader) pack() []byte { +mut res := []byte{} +if o.has_cache_key_sha { +res << vproto.pack_bytes_field(o.cache_key_sha, 1) +} + +if o.has_shader_code_sha { +res << vproto.pack_bytes_field(o.shader_code_sha, 2) +} + +return res +} + +pub fn cshaderregistershaderrequestshader_unpack(buf []byte) ?CShaderRegisterShaderRequestShader { +mut res := CShaderRegisterShaderRequestShader{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_cache_key_sha = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.cache_key_sha = v +i = ii +} + +2 { +res.has_shader_code_sha = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.shader_code_sha = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cshaderregistershaderrequestshader() CShaderRegisterShaderRequestShader { +return CShaderRegisterShaderRequestShader{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cshaderregistershaderrequestshader(o CShaderRegisterShaderRequestShader, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cshaderregistershaderrequestshader(buf []byte, tag_wiretype vproto.WireType) ?(int, CShaderRegisterShaderRequestShader) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cshaderregistershaderrequestshader_unpack(v)? +return i, unpacked +} +pub struct CShaderRegisterShaderRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +gpu_desc string +has_gpu_desc bool +driver_desc string +has_driver_desc bool +shaders []CShaderRegisterShaderRequestShader +} +pub fn (o &CShaderRegisterShaderRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_gpu_desc { +res << vproto.pack_string_field(o.gpu_desc, 2) +} + +if o.has_driver_desc { +res << vproto.pack_string_field(o.driver_desc, 3) +} + +// [packed=false] +for _, x in o.shaders { +res << zzz_vproto_internal_pack_cshaderregistershaderrequestshader(x, 4) +} + +return res +} + +pub fn cshaderregistershaderrequest_unpack(buf []byte) ?CShaderRegisterShaderRequest { +mut res := CShaderRegisterShaderRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_gpu_desc = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.gpu_desc = v +i = ii +} + +3 { +res.has_driver_desc = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.driver_desc = v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cshaderregistershaderrequestshader(cur_buf, tag_wiretype.wire_type)? +res.shaders << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cshaderregistershaderrequest() CShaderRegisterShaderRequest { +return CShaderRegisterShaderRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cshaderregistershaderrequest(o CShaderRegisterShaderRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cshaderregistershaderrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CShaderRegisterShaderRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cshaderregistershaderrequest_unpack(v)? +return i, unpacked +} +pub struct CShaderRegisterShaderResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +requested_codeids []u32 +} +pub fn (o &CShaderRegisterShaderResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.requested_codeids { +res << vproto.pack_uint32_field(x, 1) +} + +return res +} + +pub fn cshaderregistershaderresponse_unpack(buf []byte) ?CShaderRegisterShaderResponse { +mut res := CShaderRegisterShaderResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.requested_codeids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cshaderregistershaderresponse() CShaderRegisterShaderResponse { +return CShaderRegisterShaderResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cshaderregistershaderresponse(o CShaderRegisterShaderResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cshaderregistershaderresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CShaderRegisterShaderResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cshaderregistershaderresponse_unpack(v)? +return i, unpacked +} +pub struct CShaderSendShaderRequestShaderCode { +mut: +unknown_fields []vproto.UnknownField +pub mut: +shader_code_sha []byte +has_shader_code_sha bool +shader_code []byte +has_shader_code bool +} +pub fn (o &CShaderSendShaderRequestShaderCode) pack() []byte { +mut res := []byte{} +if o.has_shader_code_sha { +res << vproto.pack_bytes_field(o.shader_code_sha, 1) +} + +if o.has_shader_code { +res << vproto.pack_bytes_field(o.shader_code, 2) +} + +return res +} + +pub fn cshadersendshaderrequestshadercode_unpack(buf []byte) ?CShaderSendShaderRequestShaderCode { +mut res := CShaderSendShaderRequestShaderCode{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_shader_code_sha = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.shader_code_sha = v +i = ii +} + +2 { +res.has_shader_code = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.shader_code = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cshadersendshaderrequestshadercode() CShaderSendShaderRequestShaderCode { +return CShaderSendShaderRequestShaderCode{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cshadersendshaderrequestshadercode(o CShaderSendShaderRequestShaderCode, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cshadersendshaderrequestshadercode(buf []byte, tag_wiretype vproto.WireType) ?(int, CShaderSendShaderRequestShaderCode) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cshadersendshaderrequestshadercode_unpack(v)? +return i, unpacked +} +pub struct CShaderSendShaderRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +shaders []CShaderSendShaderRequestShaderCode +} +pub fn (o &CShaderSendShaderRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +// [packed=false] +for _, x in o.shaders { +res << zzz_vproto_internal_pack_cshadersendshaderrequestshadercode(x, 2) +} + +return res +} + +pub fn cshadersendshaderrequest_unpack(buf []byte) ?CShaderSendShaderRequest { +mut res := CShaderSendShaderRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cshadersendshaderrequestshadercode(cur_buf, tag_wiretype.wire_type)? +res.shaders << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cshadersendshaderrequest() CShaderSendShaderRequest { +return CShaderSendShaderRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cshadersendshaderrequest(o CShaderSendShaderRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cshadersendshaderrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CShaderSendShaderRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cshadersendshaderrequest_unpack(v)? +return i, unpacked +} +pub struct CShaderSendShaderResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CShaderSendShaderResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cshadersendshaderresponse_unpack(buf []byte) ?CShaderSendShaderResponse { +res := CShaderSendShaderResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cshadersendshaderresponse() CShaderSendShaderResponse { +return CShaderSendShaderResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cshadersendshaderresponse(o CShaderSendShaderResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cshadersendshaderresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CShaderSendShaderResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cshadersendshaderresponse_unpack(v)? +return i, unpacked +} +pub struct CShaderGetBucketManifestRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +gpu_desc string +has_gpu_desc bool +driver_desc string +has_driver_desc bool +} +pub fn (o &CShaderGetBucketManifestRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_gpu_desc { +res << vproto.pack_string_field(o.gpu_desc, 2) +} + +if o.has_driver_desc { +res << vproto.pack_string_field(o.driver_desc, 3) +} + +return res +} + +pub fn cshadergetbucketmanifestrequest_unpack(buf []byte) ?CShaderGetBucketManifestRequest { +mut res := CShaderGetBucketManifestRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_gpu_desc = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.gpu_desc = v +i = ii +} + +3 { +res.has_driver_desc = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.driver_desc = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cshadergetbucketmanifestrequest() CShaderGetBucketManifestRequest { +return CShaderGetBucketManifestRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cshadergetbucketmanifestrequest(o CShaderGetBucketManifestRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cshadergetbucketmanifestrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CShaderGetBucketManifestRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cshadergetbucketmanifestrequest_unpack(v)? +return i, unpacked +} +pub struct CShaderGetBucketManifestResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +manifestid u64 +has_manifestid bool +depotsize u32 +has_depotsize bool +bucketid u64 +has_bucketid bool +} +pub fn (o &CShaderGetBucketManifestResponse) pack() []byte { +mut res := []byte{} +if o.has_manifestid { +res << vproto.pack_uint64_field(o.manifestid, 1) +} + +if o.has_depotsize { +res << vproto.pack_uint32_field(o.depotsize, 2) +} + +if o.has_bucketid { +res << vproto.pack_uint64_field(o.bucketid, 3) +} + +return res +} + +pub fn cshadergetbucketmanifestresponse_unpack(buf []byte) ?CShaderGetBucketManifestResponse { +mut res := CShaderGetBucketManifestResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_manifestid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.manifestid = v +i = ii +} + +2 { +res.has_depotsize = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.depotsize = v +i = ii +} + +3 { +res.has_bucketid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.bucketid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cshadergetbucketmanifestresponse() CShaderGetBucketManifestResponse { +return CShaderGetBucketManifestResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cshadergetbucketmanifestresponse(o CShaderGetBucketManifestResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cshadergetbucketmanifestresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CShaderGetBucketManifestResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cshadergetbucketmanifestresponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_site_license.steamclient_pb.v b/proto/steammessages_site_license.steamclient_pb.v new file mode 100644 index 0000000..ac5ef83 --- /dev/null +++ b/proto/steammessages_site_license.steamclient_pb.v @@ -0,0 +1,1125 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CSiteManagerClientIncomingClientRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +site_instanceid u64 +has_site_instanceid bool +client_steamid u64 +has_client_steamid bool +client_local_ip u32 +has_client_local_ip bool +connection_key []byte +has_connection_key bool +} +pub fn (o &CSiteManagerClientIncomingClientRequest) pack() []byte { +mut res := []byte{} +if o.has_site_instanceid { +res << vproto.pack_64bit_field(o.site_instanceid, 1) +} + +if o.has_client_steamid { +res << vproto.pack_64bit_field(o.client_steamid, 2) +} + +if o.has_client_local_ip { +res << vproto.pack_32bit_field(o.client_local_ip, 3) +} + +if o.has_connection_key { +res << vproto.pack_bytes_field(o.connection_key, 4) +} + +return res +} + +pub fn csitemanagerclientincomingclientrequest_unpack(buf []byte) ?CSiteManagerClientIncomingClientRequest { +mut res := CSiteManagerClientIncomingClientRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_site_instanceid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.site_instanceid = v +i = ii +} + +2 { +res.has_client_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.client_steamid = v +i = ii +} + +3 { +res.has_client_local_ip = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.client_local_ip = v +i = ii +} + +4 { +res.has_connection_key = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.connection_key = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csitemanagerclientincomingclientrequest() CSiteManagerClientIncomingClientRequest { +return CSiteManagerClientIncomingClientRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csitemanagerclientincomingclientrequest(o CSiteManagerClientIncomingClientRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csitemanagerclientincomingclientrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CSiteManagerClientIncomingClientRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csitemanagerclientincomingclientrequest_unpack(v)? +return i, unpacked +} +pub struct CSiteManagerClientIncomingClientResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CSiteManagerClientIncomingClientResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn csitemanagerclientincomingclientresponse_unpack(buf []byte) ?CSiteManagerClientIncomingClientResponse { +res := CSiteManagerClientIncomingClientResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csitemanagerclientincomingclientresponse() CSiteManagerClientIncomingClientResponse { +return CSiteManagerClientIncomingClientResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csitemanagerclientincomingclientresponse(o CSiteManagerClientIncomingClientResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csitemanagerclientincomingclientresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CSiteManagerClientIncomingClientResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csitemanagerclientincomingclientresponse_unpack(v)? +return i, unpacked +} +pub struct CSiteLicenseClientSeatCheckoutNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +eresult u32 +has_eresult bool +} +pub fn (o &CSiteLicenseClientSeatCheckoutNotification) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_eresult { +res << vproto.pack_uint32_field(o.eresult, 2) +} + +return res +} + +pub fn csitelicenseclientseatcheckoutnotification_unpack(buf []byte) ?CSiteLicenseClientSeatCheckoutNotification { +mut res := CSiteLicenseClientSeatCheckoutNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_eresult = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csitelicenseclientseatcheckoutnotification() CSiteLicenseClientSeatCheckoutNotification { +return CSiteLicenseClientSeatCheckoutNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csitelicenseclientseatcheckoutnotification(o CSiteLicenseClientSeatCheckoutNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csitelicenseclientseatcheckoutnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CSiteLicenseClientSeatCheckoutNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csitelicenseclientseatcheckoutnotification_unpack(v)? +return i, unpacked +} +pub struct CSiteManagerClientTrackedPaymentsNotificationPayment { +mut: +unknown_fields []vproto.UnknownField +pub mut: +transid u64 +has_transid bool +steamid u64 +has_steamid bool +amount i64 +has_amount bool +ecurrency u32 +has_ecurrency bool +time_created int +has_time_created bool +purchase_status int +has_purchase_status bool +machine_name string +has_machine_name bool +persona_name string +has_persona_name bool +profile_url string +has_profile_url bool +avatar_url string +has_avatar_url bool +} +pub fn (o &CSiteManagerClientTrackedPaymentsNotificationPayment) pack() []byte { +mut res := []byte{} +if o.has_transid { +res << vproto.pack_uint64_field(o.transid, 1) +} + +if o.has_steamid { +res << vproto.pack_uint64_field(o.steamid, 2) +} + +if o.has_amount { +res << vproto.pack_int64_field(o.amount, 3) +} + +if o.has_ecurrency { +res << vproto.pack_uint32_field(o.ecurrency, 4) +} + +if o.has_time_created { +res << vproto.pack_int32_field(o.time_created, 5) +} + +if o.has_purchase_status { +res << vproto.pack_int32_field(o.purchase_status, 6) +} + +if o.has_machine_name { +res << vproto.pack_string_field(o.machine_name, 7) +} + +if o.has_persona_name { +res << vproto.pack_string_field(o.persona_name, 8) +} + +if o.has_profile_url { +res << vproto.pack_string_field(o.profile_url, 9) +} + +if o.has_avatar_url { +res << vproto.pack_string_field(o.avatar_url, 10) +} + +return res +} + +pub fn csitemanagerclienttrackedpaymentsnotificationpayment_unpack(buf []byte) ?CSiteManagerClientTrackedPaymentsNotificationPayment { +mut res := CSiteManagerClientTrackedPaymentsNotificationPayment{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_transid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.transid = v +i = ii +} + +2 { +res.has_steamid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +3 { +res.has_amount = true +ii, v := vproto.unpack_int64_field(cur_buf, tag_wiretype.wire_type)? +res.amount = v +i = ii +} + +4 { +res.has_ecurrency = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ecurrency = v +i = ii +} + +5 { +res.has_time_created = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.time_created = v +i = ii +} + +6 { +res.has_purchase_status = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.purchase_status = v +i = ii +} + +7 { +res.has_machine_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.machine_name = v +i = ii +} + +8 { +res.has_persona_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.persona_name = v +i = ii +} + +9 { +res.has_profile_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.profile_url = v +i = ii +} + +10 { +res.has_avatar_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.avatar_url = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csitemanagerclienttrackedpaymentsnotificationpayment() CSiteManagerClientTrackedPaymentsNotificationPayment { +return CSiteManagerClientTrackedPaymentsNotificationPayment{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csitemanagerclienttrackedpaymentsnotificationpayment(o CSiteManagerClientTrackedPaymentsNotificationPayment, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csitemanagerclienttrackedpaymentsnotificationpayment(buf []byte, tag_wiretype vproto.WireType) ?(int, CSiteManagerClientTrackedPaymentsNotificationPayment) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csitemanagerclienttrackedpaymentsnotificationpayment_unpack(v)? +return i, unpacked +} +pub struct CSiteManagerClientTrackedPaymentsNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +site_id u64 +has_site_id bool +payments []CSiteManagerClientTrackedPaymentsNotificationPayment +} +pub fn (o &CSiteManagerClientTrackedPaymentsNotification) pack() []byte { +mut res := []byte{} +if o.has_site_id { +res << vproto.pack_64bit_field(o.site_id, 1) +} + +// [packed=false] +for _, x in o.payments { +res << zzz_vproto_internal_pack_csitemanagerclienttrackedpaymentsnotificationpayment(x, 2) +} + +return res +} + +pub fn csitemanagerclienttrackedpaymentsnotification_unpack(buf []byte) ?CSiteManagerClientTrackedPaymentsNotification { +mut res := CSiteManagerClientTrackedPaymentsNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_site_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.site_id = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_csitemanagerclienttrackedpaymentsnotificationpayment(cur_buf, tag_wiretype.wire_type)? +res.payments << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csitemanagerclienttrackedpaymentsnotification() CSiteManagerClientTrackedPaymentsNotification { +return CSiteManagerClientTrackedPaymentsNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csitemanagerclienttrackedpaymentsnotification(o CSiteManagerClientTrackedPaymentsNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csitemanagerclienttrackedpaymentsnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CSiteManagerClientTrackedPaymentsNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csitemanagerclienttrackedpaymentsnotification_unpack(v)? +return i, unpacked +} +pub struct CSiteLicenseInitiateAssociationRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +site_steamid u64 +has_site_steamid bool +site_instanceid u64 +has_site_instanceid bool +client_local_ip u32 +has_client_local_ip bool +} +pub fn (o &CSiteLicenseInitiateAssociationRequest) pack() []byte { +mut res := []byte{} +if o.has_site_steamid { +res << vproto.pack_64bit_field(o.site_steamid, 1) +} + +if o.has_site_instanceid { +res << vproto.pack_64bit_field(o.site_instanceid, 2) +} + +if o.has_client_local_ip { +res << vproto.pack_32bit_field(o.client_local_ip, 3) +} + +return res +} + +pub fn csitelicenseinitiateassociationrequest_unpack(buf []byte) ?CSiteLicenseInitiateAssociationRequest { +mut res := CSiteLicenseInitiateAssociationRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_site_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.site_steamid = v +i = ii +} + +2 { +res.has_site_instanceid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.site_instanceid = v +i = ii +} + +3 { +res.has_client_local_ip = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.client_local_ip = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csitelicenseinitiateassociationrequest() CSiteLicenseInitiateAssociationRequest { +return CSiteLicenseInitiateAssociationRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csitelicenseinitiateassociationrequest(o CSiteLicenseInitiateAssociationRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csitelicenseinitiateassociationrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CSiteLicenseInitiateAssociationRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csitelicenseinitiateassociationrequest_unpack(v)? +return i, unpacked +} +pub struct CSiteLicenseInitiateAssociationResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +connection_key []byte +has_connection_key bool +} +pub fn (o &CSiteLicenseInitiateAssociationResponse) pack() []byte { +mut res := []byte{} +if o.has_connection_key { +res << vproto.pack_bytes_field(o.connection_key, 1) +} + +return res +} + +pub fn csitelicenseinitiateassociationresponse_unpack(buf []byte) ?CSiteLicenseInitiateAssociationResponse { +mut res := CSiteLicenseInitiateAssociationResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_connection_key = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.connection_key = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csitelicenseinitiateassociationresponse() CSiteLicenseInitiateAssociationResponse { +return CSiteLicenseInitiateAssociationResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csitelicenseinitiateassociationresponse(o CSiteLicenseInitiateAssociationResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csitelicenseinitiateassociationresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CSiteLicenseInitiateAssociationResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csitelicenseinitiateassociationresponse_unpack(v)? +return i, unpacked +} +pub struct CSiteLicenseLCsauthenticateRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +instanceid u64 +has_instanceid bool +} +pub fn (o &CSiteLicenseLCsauthenticateRequest) pack() []byte { +mut res := []byte{} +if o.has_instanceid { +res << vproto.pack_64bit_field(o.instanceid, 1) +} + +return res +} + +pub fn csitelicenselcsauthenticaterequest_unpack(buf []byte) ?CSiteLicenseLCsauthenticateRequest { +mut res := CSiteLicenseLCsauthenticateRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_instanceid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.instanceid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csitelicenselcsauthenticaterequest() CSiteLicenseLCsauthenticateRequest { +return CSiteLicenseLCsauthenticateRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csitelicenselcsauthenticaterequest(o CSiteLicenseLCsauthenticateRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csitelicenselcsauthenticaterequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CSiteLicenseLCsauthenticateRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csitelicenselcsauthenticaterequest_unpack(v)? +return i, unpacked +} +pub struct CSiteLicenseLCsauthenticateResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +site_id u64 +has_site_id bool +site_name string +has_site_name bool +new_session bool +has_new_session bool +no_site_licenses bool +has_no_site_licenses bool +} +pub fn (o &CSiteLicenseLCsauthenticateResponse) pack() []byte { +mut res := []byte{} +if o.has_site_id { +res << vproto.pack_uint64_field(o.site_id, 1) +} + +if o.has_site_name { +res << vproto.pack_string_field(o.site_name, 2) +} + +if o.has_new_session { +res << vproto.pack_bool_field(o.new_session, 3) +} + +if o.has_no_site_licenses { +res << vproto.pack_bool_field(o.no_site_licenses, 4) +} + +return res +} + +pub fn csitelicenselcsauthenticateresponse_unpack(buf []byte) ?CSiteLicenseLCsauthenticateResponse { +mut res := CSiteLicenseLCsauthenticateResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_site_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.site_id = v +i = ii +} + +2 { +res.has_site_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.site_name = v +i = ii +} + +3 { +res.has_new_session = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.new_session = v +i = ii +} + +4 { +res.has_no_site_licenses = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.no_site_licenses = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csitelicenselcsauthenticateresponse() CSiteLicenseLCsauthenticateResponse { +return CSiteLicenseLCsauthenticateResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csitelicenselcsauthenticateresponse(o CSiteLicenseLCsauthenticateResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csitelicenselcsauthenticateresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CSiteLicenseLCsauthenticateResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csitelicenselcsauthenticateresponse_unpack(v)? +return i, unpacked +} +pub struct CSiteLicenseLCsassociateUserRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +local_ip u32 +has_local_ip bool +instanceid u64 +has_instanceid bool +machine_name string +has_machine_name bool +} +pub fn (o &CSiteLicenseLCsassociateUserRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_local_ip { +res << vproto.pack_32bit_field(o.local_ip, 2) +} + +if o.has_instanceid { +res << vproto.pack_64bit_field(o.instanceid, 3) +} + +if o.has_machine_name { +res << vproto.pack_string_field(o.machine_name, 4) +} + +return res +} + +pub fn csitelicenselcsassociateuserrequest_unpack(buf []byte) ?CSiteLicenseLCsassociateUserRequest { +mut res := CSiteLicenseLCsassociateUserRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_local_ip = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.local_ip = v +i = ii +} + +3 { +res.has_instanceid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.instanceid = v +i = ii +} + +4 { +res.has_machine_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.machine_name = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csitelicenselcsassociateuserrequest() CSiteLicenseLCsassociateUserRequest { +return CSiteLicenseLCsassociateUserRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csitelicenselcsassociateuserrequest(o CSiteLicenseLCsassociateUserRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csitelicenselcsassociateuserrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CSiteLicenseLCsassociateUserRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csitelicenselcsassociateuserrequest_unpack(v)? +return i, unpacked +} +pub struct CSiteLicenseLCsassociateUserResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CSiteLicenseLCsassociateUserResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn csitelicenselcsassociateuserresponse_unpack(buf []byte) ?CSiteLicenseLCsassociateUserResponse { +res := CSiteLicenseLCsassociateUserResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csitelicenselcsassociateuserresponse() CSiteLicenseLCsassociateUserResponse { +return CSiteLicenseLCsassociateUserResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csitelicenselcsassociateuserresponse(o CSiteLicenseLCsassociateUserResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csitelicenselcsassociateuserresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CSiteLicenseLCsassociateUserResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csitelicenselcsassociateuserresponse_unpack(v)? +return i, unpacked +} +pub struct CSiteLicenseClientSeatCheckoutRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +instanceid u64 +has_instanceid bool +appid u32 +has_appid bool +} +pub fn (o &CSiteLicenseClientSeatCheckoutRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_instanceid { +res << vproto.pack_64bit_field(o.instanceid, 2) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 3) +} + +return res +} + +pub fn csitelicenseclientseatcheckoutrequest_unpack(buf []byte) ?CSiteLicenseClientSeatCheckoutRequest { +mut res := CSiteLicenseClientSeatCheckoutRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_instanceid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.instanceid = v +i = ii +} + +3 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csitelicenseclientseatcheckoutrequest() CSiteLicenseClientSeatCheckoutRequest { +return CSiteLicenseClientSeatCheckoutRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csitelicenseclientseatcheckoutrequest(o CSiteLicenseClientSeatCheckoutRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csitelicenseclientseatcheckoutrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CSiteLicenseClientSeatCheckoutRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csitelicenseclientseatcheckoutrequest_unpack(v)? +return i, unpacked +} +pub struct CSiteLicenseClientSeatCheckoutResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CSiteLicenseClientSeatCheckoutResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn csitelicenseclientseatcheckoutresponse_unpack(buf []byte) ?CSiteLicenseClientSeatCheckoutResponse { +res := CSiteLicenseClientSeatCheckoutResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csitelicenseclientseatcheckoutresponse() CSiteLicenseClientSeatCheckoutResponse { +return CSiteLicenseClientSeatCheckoutResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csitelicenseclientseatcheckoutresponse(o CSiteLicenseClientSeatCheckoutResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csitelicenseclientseatcheckoutresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CSiteLicenseClientSeatCheckoutResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csitelicenseclientseatcheckoutresponse_unpack(v)? +return i, unpacked +} +pub struct CSiteLicenseClientGetAvailableSeatsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +instanceid u64 +has_instanceid bool +appid u32 +has_appid bool +} +pub fn (o &CSiteLicenseClientGetAvailableSeatsRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_instanceid { +res << vproto.pack_64bit_field(o.instanceid, 2) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 3) +} + +return res +} + +pub fn csitelicenseclientgetavailableseatsrequest_unpack(buf []byte) ?CSiteLicenseClientGetAvailableSeatsRequest { +mut res := CSiteLicenseClientGetAvailableSeatsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_instanceid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.instanceid = v +i = ii +} + +3 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csitelicenseclientgetavailableseatsrequest() CSiteLicenseClientGetAvailableSeatsRequest { +return CSiteLicenseClientGetAvailableSeatsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csitelicenseclientgetavailableseatsrequest(o CSiteLicenseClientGetAvailableSeatsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csitelicenseclientgetavailableseatsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CSiteLicenseClientGetAvailableSeatsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csitelicenseclientgetavailableseatsrequest_unpack(v)? +return i, unpacked +} +pub struct CSiteLicenseClientGetAvailableSeatsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +available_seats u32 +has_available_seats bool +} +pub fn (o &CSiteLicenseClientGetAvailableSeatsResponse) pack() []byte { +mut res := []byte{} +if o.has_available_seats { +res << vproto.pack_uint32_field(o.available_seats, 1) +} + +return res +} + +pub fn csitelicenseclientgetavailableseatsresponse_unpack(buf []byte) ?CSiteLicenseClientGetAvailableSeatsResponse { +mut res := CSiteLicenseClientGetAvailableSeatsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_available_seats = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.available_seats = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csitelicenseclientgetavailableseatsresponse() CSiteLicenseClientGetAvailableSeatsResponse { +return CSiteLicenseClientGetAvailableSeatsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csitelicenseclientgetavailableseatsresponse(o CSiteLicenseClientGetAvailableSeatsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csitelicenseclientgetavailableseatsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CSiteLicenseClientGetAvailableSeatsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csitelicenseclientgetavailableseatsresponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_sitelicenseclient_pb.v b/proto/steammessages_sitelicenseclient_pb.v new file mode 100644 index 0000000..24a2368 --- /dev/null +++ b/proto/steammessages_sitelicenseclient_pb.v @@ -0,0 +1,474 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CMsgClientSiteInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +site_id u64 +has_site_id bool +site_name string +has_site_name bool +allow_cached_credentials bool +has_allow_cached_credentials bool +} +pub fn (o &CMsgClientSiteInfo) pack() []byte { +mut res := []byte{} +if o.has_site_id { +res << vproto.pack_uint64_field(o.site_id, 1) +} + +if o.has_site_name { +res << vproto.pack_string_field(o.site_name, 2) +} + +if o.has_allow_cached_credentials { +res << vproto.pack_bool_field(o.allow_cached_credentials, 3) +} + +return res +} + +pub fn cmsgclientsiteinfo_unpack(buf []byte) ?CMsgClientSiteInfo { +mut res := CMsgClientSiteInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_site_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.site_id = v +i = ii +} + +2 { +res.has_site_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.site_name = v +i = ii +} + +3 { +res.has_allow_cached_credentials = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.allow_cached_credentials = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientsiteinfo() CMsgClientSiteInfo { +return CMsgClientSiteInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientsiteinfo(o CMsgClientSiteInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientsiteinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientSiteInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientsiteinfo_unpack(v)? +return i, unpacked +} +pub struct CMsgClientSiteLicenseCheckout { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +} +pub fn (o &CMsgClientSiteLicenseCheckout) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +return res +} + +pub fn cmsgclientsitelicensecheckout_unpack(buf []byte) ?CMsgClientSiteLicenseCheckout { +mut res := CMsgClientSiteLicenseCheckout{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientsitelicensecheckout() CMsgClientSiteLicenseCheckout { +return CMsgClientSiteLicenseCheckout{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientsitelicensecheckout(o CMsgClientSiteLicenseCheckout, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientsitelicensecheckout(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientSiteLicenseCheckout) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientsitelicensecheckout_unpack(v)? +return i, unpacked +} +pub struct CMsgClientSiteLicenseCheckoutResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +} +pub fn (o &CMsgClientSiteLicenseCheckoutResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +return res +} + +pub fn cmsgclientsitelicensecheckoutresponse_unpack(buf []byte) ?CMsgClientSiteLicenseCheckoutResponse { +mut res := CMsgClientSiteLicenseCheckoutResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientsitelicensecheckoutresponse() CMsgClientSiteLicenseCheckoutResponse { +return CMsgClientSiteLicenseCheckoutResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientsitelicensecheckoutresponse(o CMsgClientSiteLicenseCheckoutResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientsitelicensecheckoutresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientSiteLicenseCheckoutResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientsitelicensecheckoutresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientSiteLicenseGetAvailableSeats { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +} +pub fn (o &CMsgClientSiteLicenseGetAvailableSeats) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +return res +} + +pub fn cmsgclientsitelicensegetavailableseats_unpack(buf []byte) ?CMsgClientSiteLicenseGetAvailableSeats { +mut res := CMsgClientSiteLicenseGetAvailableSeats{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientsitelicensegetavailableseats() CMsgClientSiteLicenseGetAvailableSeats { +return CMsgClientSiteLicenseGetAvailableSeats{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientsitelicensegetavailableseats(o CMsgClientSiteLicenseGetAvailableSeats, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientsitelicensegetavailableseats(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientSiteLicenseGetAvailableSeats) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientsitelicensegetavailableseats_unpack(v)? +return i, unpacked +} +pub struct CMsgClientSiteLicenseGetAvailableSeatsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +eresult int +has_eresult bool +seats u32 +has_seats bool +} +pub fn (o &CMsgClientSiteLicenseGetAvailableSeatsResponse) pack() []byte { +mut res := []byte{} +if o.has_eresult { +res << vproto.pack_int32_field(o.eresult, 1) +} + +if o.has_seats { +res << vproto.pack_uint32_field(o.seats, 2) +} + +return res +} + +pub fn cmsgclientsitelicensegetavailableseatsresponse_unpack(buf []byte) ?CMsgClientSiteLicenseGetAvailableSeatsResponse { +mut res := CMsgClientSiteLicenseGetAvailableSeatsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.eresult = v +i = ii +} + +2 { +res.has_seats = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seats = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientsitelicensegetavailableseatsresponse() CMsgClientSiteLicenseGetAvailableSeatsResponse { +return CMsgClientSiteLicenseGetAvailableSeatsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientsitelicensegetavailableseatsresponse(o CMsgClientSiteLicenseGetAvailableSeatsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientsitelicensegetavailableseatsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientSiteLicenseGetAvailableSeatsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientsitelicensegetavailableseatsresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgClientSiteLicenseGetContentCacheInfo { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CMsgClientSiteLicenseGetContentCacheInfo) pack() []byte { +res := []byte{} +return res +} + +pub fn cmsgclientsitelicensegetcontentcacheinfo_unpack(buf []byte) ?CMsgClientSiteLicenseGetContentCacheInfo { +res := CMsgClientSiteLicenseGetContentCacheInfo{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientsitelicensegetcontentcacheinfo() CMsgClientSiteLicenseGetContentCacheInfo { +return CMsgClientSiteLicenseGetContentCacheInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientsitelicensegetcontentcacheinfo(o CMsgClientSiteLicenseGetContentCacheInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientsitelicensegetcontentcacheinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientSiteLicenseGetContentCacheInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientsitelicensegetcontentcacheinfo_unpack(v)? +return i, unpacked +} +pub struct CMsgClientSiteLicenseGetContentCacheInfoResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +use_cache bool +has_use_cache bool +ipv4_address u32 +has_ipv4_address bool +port_number u32 +has_port_number bool +p2p_group u32 +has_p2p_group bool +ip_address string +has_ip_address bool +} +pub fn (o &CMsgClientSiteLicenseGetContentCacheInfoResponse) pack() []byte { +mut res := []byte{} +if o.has_use_cache { +res << vproto.pack_bool_field(o.use_cache, 1) +} + +if o.has_ipv4_address { +res << vproto.pack_uint32_field(o.ipv4_address, 2) +} + +if o.has_port_number { +res << vproto.pack_uint32_field(o.port_number, 3) +} + +if o.has_p2p_group { +res << vproto.pack_uint32_field(o.p2p_group, 4) +} + +if o.has_ip_address { +res << vproto.pack_string_field(o.ip_address, 5) +} + +return res +} + +pub fn cmsgclientsitelicensegetcontentcacheinforesponse_unpack(buf []byte) ?CMsgClientSiteLicenseGetContentCacheInfoResponse { +mut res := CMsgClientSiteLicenseGetContentCacheInfoResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_use_cache = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.use_cache = v +i = ii +} + +2 { +res.has_ipv4_address = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ipv4_address = v +i = ii +} + +3 { +res.has_port_number = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.port_number = v +i = ii +} + +4 { +res.has_p2p_group = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.p2p_group = v +i = ii +} + +5 { +res.has_ip_address = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.ip_address = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgclientsitelicensegetcontentcacheinforesponse() CMsgClientSiteLicenseGetContentCacheInfoResponse { +return CMsgClientSiteLicenseGetContentCacheInfoResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgclientsitelicensegetcontentcacheinforesponse(o CMsgClientSiteLicenseGetContentCacheInfoResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgclientsitelicensegetcontentcacheinforesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgClientSiteLicenseGetContentCacheInfoResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgclientsitelicensegetcontentcacheinforesponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_siteserverui_pb.v b/proto/steammessages_siteserverui_pb.v new file mode 100644 index 0000000..3adf46b --- /dev/null +++ b/proto/steammessages_siteserverui_pb.v @@ -0,0 +1,1619 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct SiteServerUIloginRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +username string +has_username bool +password string +has_password bool +steamguardcode string +has_steamguardcode bool +remember_password bool +has_remember_password bool +} +pub fn (o &SiteServerUIloginRequest) pack() []byte { +mut res := []byte{} +if o.has_username { +res << vproto.pack_string_field(o.username, 1) +} + +if o.has_password { +res << vproto.pack_string_field(o.password, 2) +} + +if o.has_steamguardcode { +res << vproto.pack_string_field(o.steamguardcode, 3) +} + +if o.has_remember_password { +res << vproto.pack_bool_field(o.remember_password, 4) +} + +return res +} + +pub fn siteserveruiloginrequest_unpack(buf []byte) ?SiteServerUIloginRequest { +mut res := SiteServerUIloginRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_username = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.username = v +i = ii +} + +2 { +res.has_password = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.password = v +i = ii +} + +3 { +res.has_steamguardcode = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.steamguardcode = v +i = ii +} + +4 { +res.has_remember_password = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.remember_password = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_siteserveruiloginrequest() SiteServerUIloginRequest { +return SiteServerUIloginRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_siteserveruiloginrequest(o SiteServerUIloginRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_siteserveruiloginrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, SiteServerUIloginRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := siteserveruiloginrequest_unpack(v)? +return i, unpacked +} +pub struct SiteServerUIloginResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +logon_state int +has_logon_state bool +logon_eresult int +has_logon_eresult bool +} +pub fn (o &SiteServerUIloginResponse) pack() []byte { +mut res := []byte{} +if o.has_logon_state { +res << vproto.pack_int32_field(o.logon_state, 1) +} + +if o.has_logon_eresult { +res << vproto.pack_int32_field(o.logon_eresult, 2) +} + +return res +} + +pub fn siteserveruiloginresponse_unpack(buf []byte) ?SiteServerUIloginResponse { +mut res := SiteServerUIloginResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_logon_state = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.logon_state = v +i = ii +} + +2 { +res.has_logon_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.logon_eresult = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_siteserveruiloginresponse() SiteServerUIloginResponse { +return SiteServerUIloginResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_siteserveruiloginresponse(o SiteServerUIloginResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_siteserveruiloginresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, SiteServerUIloginResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := siteserveruiloginresponse_unpack(v)? +return i, unpacked +} +pub struct SiteServerUIloginStatusRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &SiteServerUIloginStatusRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn siteserveruiloginstatusrequest_unpack(buf []byte) ?SiteServerUIloginStatusRequest { +res := SiteServerUIloginStatusRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_siteserveruiloginstatusrequest() SiteServerUIloginStatusRequest { +return SiteServerUIloginStatusRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_siteserveruiloginstatusrequest(o SiteServerUIloginStatusRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_siteserveruiloginstatusrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, SiteServerUIloginStatusRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := siteserveruiloginstatusrequest_unpack(v)? +return i, unpacked +} +pub struct SiteServerUIloginStatusResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +username string +has_username bool +cached_credentials bool +has_cached_credentials bool +logon_state int +has_logon_state bool +logon_eresult int +has_logon_eresult bool +} +pub fn (o &SiteServerUIloginStatusResponse) pack() []byte { +mut res := []byte{} +if o.has_username { +res << vproto.pack_string_field(o.username, 1) +} + +if o.has_cached_credentials { +res << vproto.pack_bool_field(o.cached_credentials, 2) +} + +if o.has_logon_state { +res << vproto.pack_int32_field(o.logon_state, 3) +} + +if o.has_logon_eresult { +res << vproto.pack_int32_field(o.logon_eresult, 4) +} + +return res +} + +pub fn siteserveruiloginstatusresponse_unpack(buf []byte) ?SiteServerUIloginStatusResponse { +mut res := SiteServerUIloginStatusResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_username = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.username = v +i = ii +} + +2 { +res.has_cached_credentials = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.cached_credentials = v +i = ii +} + +3 { +res.has_logon_state = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.logon_state = v +i = ii +} + +4 { +res.has_logon_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.logon_eresult = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_siteserveruiloginstatusresponse() SiteServerUIloginStatusResponse { +return SiteServerUIloginStatusResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_siteserveruiloginstatusresponse(o SiteServerUIloginStatusResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_siteserveruiloginstatusresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, SiteServerUIloginStatusResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := siteserveruiloginstatusresponse_unpack(v)? +return i, unpacked +} +pub struct SiteServerUIcancelLoginRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &SiteServerUIcancelLoginRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn siteserveruicancelloginrequest_unpack(buf []byte) ?SiteServerUIcancelLoginRequest { +res := SiteServerUIcancelLoginRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_siteserveruicancelloginrequest() SiteServerUIcancelLoginRequest { +return SiteServerUIcancelLoginRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_siteserveruicancelloginrequest(o SiteServerUIcancelLoginRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_siteserveruicancelloginrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, SiteServerUIcancelLoginRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := siteserveruicancelloginrequest_unpack(v)? +return i, unpacked +} +pub struct SiteServerUIcancelLoginResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +logon_state int +has_logon_state bool +logon_eresult int +has_logon_eresult bool +} +pub fn (o &SiteServerUIcancelLoginResponse) pack() []byte { +mut res := []byte{} +if o.has_logon_state { +res << vproto.pack_int32_field(o.logon_state, 1) +} + +if o.has_logon_eresult { +res << vproto.pack_int32_field(o.logon_eresult, 2) +} + +return res +} + +pub fn siteserveruicancelloginresponse_unpack(buf []byte) ?SiteServerUIcancelLoginResponse { +mut res := SiteServerUIcancelLoginResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_logon_state = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.logon_state = v +i = ii +} + +2 { +res.has_logon_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.logon_eresult = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_siteserveruicancelloginresponse() SiteServerUIcancelLoginResponse { +return SiteServerUIcancelLoginResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_siteserveruicancelloginresponse(o SiteServerUIcancelLoginResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_siteserveruicancelloginresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, SiteServerUIcancelLoginResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := siteserveruicancelloginresponse_unpack(v)? +return i, unpacked +} +pub struct SiteServerUIlogoutRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &SiteServerUIlogoutRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn siteserveruilogoutrequest_unpack(buf []byte) ?SiteServerUIlogoutRequest { +res := SiteServerUIlogoutRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_siteserveruilogoutrequest() SiteServerUIlogoutRequest { +return SiteServerUIlogoutRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_siteserveruilogoutrequest(o SiteServerUIlogoutRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_siteserveruilogoutrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, SiteServerUIlogoutRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := siteserveruilogoutrequest_unpack(v)? +return i, unpacked +} +pub struct SiteServerUIlogoutResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +logon_state int +has_logon_state bool +logout_eresult int +has_logout_eresult bool +} +pub fn (o &SiteServerUIlogoutResponse) pack() []byte { +mut res := []byte{} +if o.has_logon_state { +res << vproto.pack_int32_field(o.logon_state, 1) +} + +if o.has_logout_eresult { +res << vproto.pack_int32_field(o.logout_eresult, 2) +} + +return res +} + +pub fn siteserveruilogoutresponse_unpack(buf []byte) ?SiteServerUIlogoutResponse { +mut res := SiteServerUIlogoutResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_logon_state = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.logon_state = v +i = ii +} + +2 { +res.has_logout_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.logout_eresult = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_siteserveruilogoutresponse() SiteServerUIlogoutResponse { +return SiteServerUIlogoutResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_siteserveruilogoutresponse(o SiteServerUIlogoutResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_siteserveruilogoutresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, SiteServerUIlogoutResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := siteserveruilogoutresponse_unpack(v)? +return i, unpacked +} +pub struct SiteServerUIquitRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +restart bool +has_restart bool +} +pub fn (o &SiteServerUIquitRequest) pack() []byte { +mut res := []byte{} +if o.has_restart { +res << vproto.pack_bool_field(o.restart, 1) +} + +return res +} + +pub fn siteserveruiquitrequest_unpack(buf []byte) ?SiteServerUIquitRequest { +mut res := SiteServerUIquitRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_restart = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.restart = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_siteserveruiquitrequest() SiteServerUIquitRequest { +return SiteServerUIquitRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_siteserveruiquitrequest(o SiteServerUIquitRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_siteserveruiquitrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, SiteServerUIquitRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := siteserveruiquitrequest_unpack(v)? +return i, unpacked +} +pub struct SiteServerUIquitResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &SiteServerUIquitResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn siteserveruiquitresponse_unpack(buf []byte) ?SiteServerUIquitResponse { +res := SiteServerUIquitResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_siteserveruiquitresponse() SiteServerUIquitResponse { +return SiteServerUIquitResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_siteserveruiquitresponse(o SiteServerUIquitResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_siteserveruiquitresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, SiteServerUIquitResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := siteserveruiquitresponse_unpack(v)? +return i, unpacked +} +pub struct SiteServerUIstatusRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &SiteServerUIstatusRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn siteserveruistatusrequest_unpack(buf []byte) ?SiteServerUIstatusRequest { +res := SiteServerUIstatusRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_siteserveruistatusrequest() SiteServerUIstatusRequest { +return SiteServerUIstatusRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_siteserveruistatusrequest(o SiteServerUIstatusRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_siteserveruistatusrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, SiteServerUIstatusRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := siteserveruistatusrequest_unpack(v)? +return i, unpacked +} +pub struct SiteServerUIstatusResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +logon_state int +has_logon_state bool +logon_eresult int +has_logon_eresult bool +connected bool +has_connected bool +cache_enabled bool +has_cache_enabled bool +acct_status int +has_acct_status bool +} +pub fn (o &SiteServerUIstatusResponse) pack() []byte { +mut res := []byte{} +if o.has_logon_state { +res << vproto.pack_int32_field(o.logon_state, 1) +} + +if o.has_logon_eresult { +res << vproto.pack_int32_field(o.logon_eresult, 2) +} + +if o.has_connected { +res << vproto.pack_bool_field(o.connected, 3) +} + +if o.has_cache_enabled { +res << vproto.pack_bool_field(o.cache_enabled, 4) +} + +if o.has_acct_status { +res << vproto.pack_int32_field(o.acct_status, 5) +} + +return res +} + +pub fn siteserveruistatusresponse_unpack(buf []byte) ?SiteServerUIstatusResponse { +mut res := SiteServerUIstatusResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_logon_state = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.logon_state = v +i = ii +} + +2 { +res.has_logon_eresult = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.logon_eresult = v +i = ii +} + +3 { +res.has_connected = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.connected = v +i = ii +} + +4 { +res.has_cache_enabled = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.cache_enabled = v +i = ii +} + +5 { +res.has_acct_status = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.acct_status = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_siteserveruistatusresponse() SiteServerUIstatusResponse { +return SiteServerUIstatusResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_siteserveruistatusresponse(o SiteServerUIstatusResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_siteserveruistatusresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, SiteServerUIstatusResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := siteserveruistatusresponse_unpack(v)? +return i, unpacked +} +pub struct SiteServerUIgetLanguageRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &SiteServerUIgetLanguageRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn siteserveruigetlanguagerequest_unpack(buf []byte) ?SiteServerUIgetLanguageRequest { +res := SiteServerUIgetLanguageRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_siteserveruigetlanguagerequest() SiteServerUIgetLanguageRequest { +return SiteServerUIgetLanguageRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_siteserveruigetlanguagerequest(o SiteServerUIgetLanguageRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_siteserveruigetlanguagerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, SiteServerUIgetLanguageRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := siteserveruigetlanguagerequest_unpack(v)? +return i, unpacked +} +pub struct SiteServerUIgetLanguageResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +language string +has_language bool +} +pub fn (o &SiteServerUIgetLanguageResponse) pack() []byte { +mut res := []byte{} +if o.has_language { +res << vproto.pack_string_field(o.language, 1) +} + +return res +} + +pub fn siteserveruigetlanguageresponse_unpack(buf []byte) ?SiteServerUIgetLanguageResponse { +mut res := SiteServerUIgetLanguageResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_language = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_siteserveruigetlanguageresponse() SiteServerUIgetLanguageResponse { +return SiteServerUIgetLanguageResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_siteserveruigetlanguageresponse(o SiteServerUIgetLanguageResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_siteserveruigetlanguageresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, SiteServerUIgetLanguageResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := siteserveruigetlanguageresponse_unpack(v)? +return i, unpacked +} +pub struct SiteServerUIsetLanguageRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +language string +has_language bool +} +pub fn (o &SiteServerUIsetLanguageRequest) pack() []byte { +mut res := []byte{} +if o.has_language { +res << vproto.pack_string_field(o.language, 1) +} + +return res +} + +pub fn siteserveruisetlanguagerequest_unpack(buf []byte) ?SiteServerUIsetLanguageRequest { +mut res := SiteServerUIsetLanguageRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_language = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_siteserveruisetlanguagerequest() SiteServerUIsetLanguageRequest { +return SiteServerUIsetLanguageRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_siteserveruisetlanguagerequest(o SiteServerUIsetLanguageRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_siteserveruisetlanguagerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, SiteServerUIsetLanguageRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := siteserveruisetlanguagerequest_unpack(v)? +return i, unpacked +} +pub struct SiteServerUIsetLanguageResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &SiteServerUIsetLanguageResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn siteserveruisetlanguageresponse_unpack(buf []byte) ?SiteServerUIsetLanguageResponse { +res := SiteServerUIsetLanguageResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_siteserveruisetlanguageresponse() SiteServerUIsetLanguageResponse { +return SiteServerUIsetLanguageResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_siteserveruisetlanguageresponse(o SiteServerUIsetLanguageResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_siteserveruisetlanguageresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, SiteServerUIsetLanguageResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := siteserveruisetlanguageresponse_unpack(v)? +return i, unpacked +} +pub struct SiteServerUIclientStatusRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &SiteServerUIclientStatusRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn siteserveruiclientstatusrequest_unpack(buf []byte) ?SiteServerUIclientStatusRequest { +res := SiteServerUIclientStatusRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_siteserveruiclientstatusrequest() SiteServerUIclientStatusRequest { +return SiteServerUIclientStatusRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_siteserveruiclientstatusrequest(o SiteServerUIclientStatusRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_siteserveruiclientstatusrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, SiteServerUIclientStatusRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := siteserveruiclientstatusrequest_unpack(v)? +return i, unpacked +} +pub struct SiteServerUIclientStatusResponseClientInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +ip u32 +has_ip bool +hostname string +has_hostname bool +connected bool +has_connected bool +instance_id u64 +has_instance_id bool +} +pub fn (o &SiteServerUIclientStatusResponseClientInfo) pack() []byte { +mut res := []byte{} +if o.has_ip { +res << vproto.pack_uint32_field(o.ip, 1) +} + +if o.has_hostname { +res << vproto.pack_string_field(o.hostname, 2) +} + +if o.has_connected { +res << vproto.pack_bool_field(o.connected, 3) +} + +if o.has_instance_id { +res << vproto.pack_uint64_field(o.instance_id, 4) +} + +return res +} + +pub fn siteserveruiclientstatusresponseclientinfo_unpack(buf []byte) ?SiteServerUIclientStatusResponseClientInfo { +mut res := SiteServerUIclientStatusResponseClientInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_ip = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ip = v +i = ii +} + +2 { +res.has_hostname = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.hostname = v +i = ii +} + +3 { +res.has_connected = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.connected = v +i = ii +} + +4 { +res.has_instance_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.instance_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_siteserveruiclientstatusresponseclientinfo() SiteServerUIclientStatusResponseClientInfo { +return SiteServerUIclientStatusResponseClientInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_siteserveruiclientstatusresponseclientinfo(o SiteServerUIclientStatusResponseClientInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_siteserveruiclientstatusresponseclientinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, SiteServerUIclientStatusResponseClientInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := siteserveruiclientstatusresponseclientinfo_unpack(v)? +return i, unpacked +} +pub struct SiteServerUIclientStatusResponsePayment { +mut: +unknown_fields []vproto.UnknownField +pub mut: +transid u64 +has_transid bool +steamid u64 +has_steamid bool +amount string +has_amount bool +time_created int +has_time_created bool +purchase_status int +has_purchase_status bool +hostname string +has_hostname bool +persona_name string +has_persona_name bool +profile_url string +has_profile_url bool +avatar_url string +has_avatar_url bool +} +pub fn (o &SiteServerUIclientStatusResponsePayment) pack() []byte { +mut res := []byte{} +if o.has_transid { +res << vproto.pack_uint64_field(o.transid, 1) +} + +if o.has_steamid { +res << vproto.pack_uint64_field(o.steamid, 2) +} + +if o.has_amount { +res << vproto.pack_string_field(o.amount, 3) +} + +if o.has_time_created { +res << vproto.pack_int32_field(o.time_created, 4) +} + +if o.has_purchase_status { +res << vproto.pack_int32_field(o.purchase_status, 5) +} + +if o.has_hostname { +res << vproto.pack_string_field(o.hostname, 6) +} + +if o.has_persona_name { +res << vproto.pack_string_field(o.persona_name, 7) +} + +if o.has_profile_url { +res << vproto.pack_string_field(o.profile_url, 8) +} + +if o.has_avatar_url { +res << vproto.pack_string_field(o.avatar_url, 9) +} + +return res +} + +pub fn siteserveruiclientstatusresponsepayment_unpack(buf []byte) ?SiteServerUIclientStatusResponsePayment { +mut res := SiteServerUIclientStatusResponsePayment{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_transid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.transid = v +i = ii +} + +2 { +res.has_steamid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +3 { +res.has_amount = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.amount = v +i = ii +} + +4 { +res.has_time_created = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.time_created = v +i = ii +} + +5 { +res.has_purchase_status = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.purchase_status = v +i = ii +} + +6 { +res.has_hostname = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.hostname = v +i = ii +} + +7 { +res.has_persona_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.persona_name = v +i = ii +} + +8 { +res.has_profile_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.profile_url = v +i = ii +} + +9 { +res.has_avatar_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.avatar_url = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_siteserveruiclientstatusresponsepayment() SiteServerUIclientStatusResponsePayment { +return SiteServerUIclientStatusResponsePayment{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_siteserveruiclientstatusresponsepayment(o SiteServerUIclientStatusResponsePayment, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_siteserveruiclientstatusresponsepayment(buf []byte, tag_wiretype vproto.WireType) ?(int, SiteServerUIclientStatusResponsePayment) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := siteserveruiclientstatusresponsepayment_unpack(v)? +return i, unpacked +} +pub struct SiteServerUIclientStatusResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +clients []SiteServerUIclientStatusResponseClientInfo +payments []SiteServerUIclientStatusResponsePayment +} +pub fn (o &SiteServerUIclientStatusResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.clients { +res << zzz_vproto_internal_pack_siteserveruiclientstatusresponseclientinfo(x, 4) +} + +// [packed=false] +for _, x in o.payments { +res << zzz_vproto_internal_pack_siteserveruiclientstatusresponsepayment(x, 5) +} + +return res +} + +pub fn siteserveruiclientstatusresponse_unpack(buf []byte) ?SiteServerUIclientStatusResponse { +mut res := SiteServerUIclientStatusResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_siteserveruiclientstatusresponseclientinfo(cur_buf, tag_wiretype.wire_type)? +res.clients << v +i = ii +} + +5 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_siteserveruiclientstatusresponsepayment(cur_buf, tag_wiretype.wire_type)? +res.payments << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_siteserveruiclientstatusresponse() SiteServerUIclientStatusResponse { +return SiteServerUIclientStatusResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_siteserveruiclientstatusresponse(o SiteServerUIclientStatusResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_siteserveruiclientstatusresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, SiteServerUIclientStatusResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := siteserveruiclientstatusresponse_unpack(v)? +return i, unpacked +} +pub struct SiteServerUIcontentCacheStatusRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &SiteServerUIcontentCacheStatusRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn siteserveruicontentcachestatusrequest_unpack(buf []byte) ?SiteServerUIcontentCacheStatusRequest { +res := SiteServerUIcontentCacheStatusRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_siteserveruicontentcachestatusrequest() SiteServerUIcontentCacheStatusRequest { +return SiteServerUIcontentCacheStatusRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_siteserveruicontentcachestatusrequest(o SiteServerUIcontentCacheStatusRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_siteserveruicontentcachestatusrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, SiteServerUIcontentCacheStatusRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := siteserveruicontentcachestatusrequest_unpack(v)? +return i, unpacked +} +pub struct SiteServerUIcontentCacheStatusResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +enabled bool +has_enabled bool +port u32 +has_port bool +cache_location string +has_cache_location bool +max_size_gb u32 +has_max_size_gb bool +p2p_enabled bool +has_p2p_enabled bool +explicit_ip_address string +has_explicit_ip_address bool +external_process bool +has_external_process bool +current_size_gb u32 +has_current_size_gb bool +current_bw u64 +has_current_bw bool +total_bytes_served u64 +has_total_bytes_served bool +} +pub fn (o &SiteServerUIcontentCacheStatusResponse) pack() []byte { +mut res := []byte{} +if o.has_enabled { +res << vproto.pack_bool_field(o.enabled, 1) +} + +if o.has_port { +res << vproto.pack_uint32_field(o.port, 2) +} + +if o.has_cache_location { +res << vproto.pack_string_field(o.cache_location, 3) +} + +if o.has_max_size_gb { +res << vproto.pack_uint32_field(o.max_size_gb, 4) +} + +if o.has_p2p_enabled { +res << vproto.pack_bool_field(o.p2p_enabled, 5) +} + +if o.has_explicit_ip_address { +res << vproto.pack_string_field(o.explicit_ip_address, 9) +} + +if o.has_external_process { +res << vproto.pack_bool_field(o.external_process, 10) +} + +if o.has_current_size_gb { +res << vproto.pack_uint32_field(o.current_size_gb, 6) +} + +if o.has_current_bw { +res << vproto.pack_uint64_field(o.current_bw, 7) +} + +if o.has_total_bytes_served { +res << vproto.pack_uint64_field(o.total_bytes_served, 8) +} + +return res +} + +pub fn siteserveruicontentcachestatusresponse_unpack(buf []byte) ?SiteServerUIcontentCacheStatusResponse { +mut res := SiteServerUIcontentCacheStatusResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_enabled = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enabled = v +i = ii +} + +2 { +res.has_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.port = v +i = ii +} + +3 { +res.has_cache_location = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.cache_location = v +i = ii +} + +4 { +res.has_max_size_gb = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.max_size_gb = v +i = ii +} + +5 { +res.has_p2p_enabled = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.p2p_enabled = v +i = ii +} + +9 { +res.has_explicit_ip_address = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.explicit_ip_address = v +i = ii +} + +10 { +res.has_external_process = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.external_process = v +i = ii +} + +6 { +res.has_current_size_gb = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.current_size_gb = v +i = ii +} + +7 { +res.has_current_bw = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.current_bw = v +i = ii +} + +8 { +res.has_total_bytes_served = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.total_bytes_served = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_siteserveruicontentcachestatusresponse() SiteServerUIcontentCacheStatusResponse { +return SiteServerUIcontentCacheStatusResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_siteserveruicontentcachestatusresponse(o SiteServerUIcontentCacheStatusResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_siteserveruicontentcachestatusresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, SiteServerUIcontentCacheStatusResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := siteserveruicontentcachestatusresponse_unpack(v)? +return i, unpacked +} +pub struct SiteServerUIcontentCacheConfigRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +enabled bool +has_enabled bool +port u32 +has_port bool +cache_location string +has_cache_location bool +max_size_gb u32 +has_max_size_gb bool +p2p_enabled bool +has_p2p_enabled bool +external_process bool +has_external_process bool +explicit_ip_address string +has_explicit_ip_address bool +} +pub fn (o &SiteServerUIcontentCacheConfigRequest) pack() []byte { +mut res := []byte{} +if o.has_enabled { +res << vproto.pack_bool_field(o.enabled, 1) +} + +if o.has_port { +res << vproto.pack_uint32_field(o.port, 2) +} + +if o.has_cache_location { +res << vproto.pack_string_field(o.cache_location, 3) +} + +if o.has_max_size_gb { +res << vproto.pack_uint32_field(o.max_size_gb, 4) +} + +if o.has_p2p_enabled { +res << vproto.pack_bool_field(o.p2p_enabled, 5) +} + +if o.has_external_process { +res << vproto.pack_bool_field(o.external_process, 6) +} + +if o.has_explicit_ip_address { +res << vproto.pack_string_field(o.explicit_ip_address, 7) +} + +return res +} + +pub fn siteserveruicontentcacheconfigrequest_unpack(buf []byte) ?SiteServerUIcontentCacheConfigRequest { +mut res := SiteServerUIcontentCacheConfigRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_enabled = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enabled = v +i = ii +} + +2 { +res.has_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.port = v +i = ii +} + +3 { +res.has_cache_location = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.cache_location = v +i = ii +} + +4 { +res.has_max_size_gb = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.max_size_gb = v +i = ii +} + +5 { +res.has_p2p_enabled = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.p2p_enabled = v +i = ii +} + +6 { +res.has_external_process = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.external_process = v +i = ii +} + +7 { +res.has_explicit_ip_address = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.explicit_ip_address = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_siteserveruicontentcacheconfigrequest() SiteServerUIcontentCacheConfigRequest { +return SiteServerUIcontentCacheConfigRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_siteserveruicontentcacheconfigrequest(o SiteServerUIcontentCacheConfigRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_siteserveruicontentcacheconfigrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, SiteServerUIcontentCacheConfigRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := siteserveruicontentcacheconfigrequest_unpack(v)? +return i, unpacked +} +pub struct SiteServerUIcontentCacheConfigResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &SiteServerUIcontentCacheConfigResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn siteserveruicontentcacheconfigresponse_unpack(buf []byte) ?SiteServerUIcontentCacheConfigResponse { +res := SiteServerUIcontentCacheConfigResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_siteserveruicontentcacheconfigresponse() SiteServerUIcontentCacheConfigResponse { +return SiteServerUIcontentCacheConfigResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_siteserveruicontentcacheconfigresponse(o SiteServerUIcontentCacheConfigResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_siteserveruicontentcacheconfigresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, SiteServerUIcontentCacheConfigResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := siteserveruicontentcacheconfigresponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_star.steamclient_pb.v b/proto/steammessages_star.steamclient_pb.v new file mode 100644 index 0000000..cb12b21 --- /dev/null +++ b/proto/steammessages_star.steamclient_pb.v @@ -0,0 +1,662 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +[_allow_multiple_values] +enum EStarglyphWriteResult { +k_e_star_glyphwriteresult_success = 0 +k_e_star_glyphwriteresult_invalidmessage = 1 +k_e_star_glyphwriteresult_invalidjson = 2 +k_e_star_glyphwriteresult_sqlerror = 3 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_estarglyphwriteresult(e EStarglyphWriteResult, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_estarglyphwriteresult(buf []byte, tag_wiretype vproto.WireType) ?(int, EStarglyphWriteResult) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EStarglyphWriteResult(v) +} +pub struct CStarkeyValueQuery { +mut: +unknown_fields []vproto.UnknownField +pub mut: +key string +has_key bool +value string +has_value bool +} +pub fn (o &CStarkeyValueQuery) pack() []byte { +mut res := []byte{} +if o.has_key { +res << vproto.pack_string_field(o.key, 1) +} + +if o.has_value { +res << vproto.pack_string_field(o.value, 2) +} + +return res +} + +pub fn cstarkeyvaluequery_unpack(buf []byte) ?CStarkeyValueQuery { +mut res := CStarkeyValueQuery{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_key = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.key = v +i = ii +} + +2 { +res.has_value = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.value = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstarkeyvaluequery() CStarkeyValueQuery { +return CStarkeyValueQuery{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstarkeyvaluequery(o CStarkeyValueQuery, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstarkeyvaluequery(buf []byte, tag_wiretype vproto.WireType) ?(int, CStarkeyValueQuery) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstarkeyvaluequery_unpack(v)? +return i, unpacked +} +pub struct CStarglyphQueryParams { +mut: +unknown_fields []vproto.UnknownField +pub mut: +bundle_id u64 +has_bundle_id bool +queries []CStarkeyValueQuery +} +pub fn (o &CStarglyphQueryParams) pack() []byte { +mut res := []byte{} +if o.has_bundle_id { +res << vproto.pack_uint64_field(o.bundle_id, 1) +} + +// [packed=false] +for _, x in o.queries { +res << zzz_vproto_internal_pack_cstarkeyvaluequery(x, 2) +} + +return res +} + +pub fn cstarglyphqueryparams_unpack(buf []byte) ?CStarglyphQueryParams { +mut res := CStarglyphQueryParams{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_bundle_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.bundle_id = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cstarkeyvaluequery(cur_buf, tag_wiretype.wire_type)? +res.queries << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstarglyphqueryparams() CStarglyphQueryParams { +return CStarglyphQueryParams{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstarglyphqueryparams(o CStarglyphQueryParams, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstarglyphqueryparams(buf []byte, tag_wiretype vproto.WireType) ?(int, CStarglyphQueryParams) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstarglyphqueryparams_unpack(v)? +return i, unpacked +} +pub struct CStarreadGlyphDataRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +query_params CStarglyphQueryParams +has_query_params bool +last_modified_time_lower_limit string +has_last_modified_time_lower_limit bool +} +pub fn (o &CStarreadGlyphDataRequest) pack() []byte { +mut res := []byte{} +if o.has_query_params { +res << zzz_vproto_internal_pack_cstarglyphqueryparams(o.query_params, 1) +} + +if o.has_last_modified_time_lower_limit { +res << vproto.pack_string_field(o.last_modified_time_lower_limit, 2) +} + +return res +} + +pub fn cstarreadglyphdatarequest_unpack(buf []byte) ?CStarreadGlyphDataRequest { +mut res := CStarreadGlyphDataRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_query_params = true +ii, v := zzz_vproto_internal_unpack_cstarglyphqueryparams(cur_buf, tag_wiretype.wire_type)? +res.query_params = v +i = ii +} + +2 { +res.has_last_modified_time_lower_limit = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.last_modified_time_lower_limit = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstarreadglyphdatarequest() CStarreadGlyphDataRequest { +return CStarreadGlyphDataRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstarreadglyphdatarequest(o CStarreadGlyphDataRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstarreadglyphdatarequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CStarreadGlyphDataRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstarreadglyphdatarequest_unpack(v)? +return i, unpacked +} +pub struct CStarglyphData { +mut: +unknown_fields []vproto.UnknownField +pub mut: +glyph_guid []byte +has_glyph_guid bool +glyph_last_modified string +has_glyph_last_modified bool +glyph_json_data string +has_glyph_json_data bool +} +pub fn (o &CStarglyphData) pack() []byte { +mut res := []byte{} +if o.has_glyph_guid { +res << vproto.pack_bytes_field(o.glyph_guid, 1) +} + +if o.has_glyph_last_modified { +res << vproto.pack_string_field(o.glyph_last_modified, 2) +} + +if o.has_glyph_json_data { +res << vproto.pack_string_field(o.glyph_json_data, 3) +} + +return res +} + +pub fn cstarglyphdata_unpack(buf []byte) ?CStarglyphData { +mut res := CStarglyphData{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_glyph_guid = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.glyph_guid = v +i = ii +} + +2 { +res.has_glyph_last_modified = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.glyph_last_modified = v +i = ii +} + +3 { +res.has_glyph_json_data = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.glyph_json_data = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstarglyphdata() CStarglyphData { +return CStarglyphData{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstarglyphdata(o CStarglyphData, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstarglyphdata(buf []byte, tag_wiretype vproto.WireType) ?(int, CStarglyphData) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstarglyphdata_unpack(v)? +return i, unpacked +} +pub struct CStarwriteGlyphDataRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +bundle_id u64 +has_bundle_id bool +glyph_data []CStarglyphData +} +pub fn (o &CStarwriteGlyphDataRequest) pack() []byte { +mut res := []byte{} +if o.has_bundle_id { +res << vproto.pack_uint64_field(o.bundle_id, 1) +} + +// [packed=false] +for _, x in o.glyph_data { +res << zzz_vproto_internal_pack_cstarglyphdata(x, 2) +} + +return res +} + +pub fn cstarwriteglyphdatarequest_unpack(buf []byte) ?CStarwriteGlyphDataRequest { +mut res := CStarwriteGlyphDataRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_bundle_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.bundle_id = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cstarglyphdata(cur_buf, tag_wiretype.wire_type)? +res.glyph_data << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstarwriteglyphdatarequest() CStarwriteGlyphDataRequest { +return CStarwriteGlyphDataRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstarwriteglyphdatarequest(o CStarwriteGlyphDataRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstarwriteglyphdatarequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CStarwriteGlyphDataRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstarwriteglyphdatarequest_unpack(v)? +return i, unpacked +} +pub struct CStarrequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +read_glyph_data CStarreadGlyphDataRequest +has_read_glyph_data bool +write_glyph_data CStarwriteGlyphDataRequest +has_write_glyph_data bool +} +pub fn (o &CStarrequest) pack() []byte { +mut res := []byte{} +if o.has_read_glyph_data { +res << zzz_vproto_internal_pack_cstarreadglyphdatarequest(o.read_glyph_data, 1) +} + +if o.has_write_glyph_data { +res << zzz_vproto_internal_pack_cstarwriteglyphdatarequest(o.write_glyph_data, 2) +} + +return res +} + +pub fn cstarrequest_unpack(buf []byte) ?CStarrequest { +mut res := CStarrequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_read_glyph_data = true +ii, v := zzz_vproto_internal_unpack_cstarreadglyphdatarequest(cur_buf, tag_wiretype.wire_type)? +res.read_glyph_data = v +i = ii +} + +2 { +res.has_write_glyph_data = true +ii, v := zzz_vproto_internal_unpack_cstarwriteglyphdatarequest(cur_buf, tag_wiretype.wire_type)? +res.write_glyph_data = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstarrequest() CStarrequest { +return CStarrequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstarrequest(o CStarrequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstarrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CStarrequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstarrequest_unpack(v)? +return i, unpacked +} +pub struct CStarreadGlyphDataResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +bundle_id u64 +has_bundle_id bool +glyph_data []CStarglyphData +} +pub fn (o &CStarreadGlyphDataResponse) pack() []byte { +mut res := []byte{} +if o.has_bundle_id { +res << vproto.pack_uint64_field(o.bundle_id, 1) +} + +// [packed=false] +for _, x in o.glyph_data { +res << zzz_vproto_internal_pack_cstarglyphdata(x, 2) +} + +return res +} + +pub fn cstarreadglyphdataresponse_unpack(buf []byte) ?CStarreadGlyphDataResponse { +mut res := CStarreadGlyphDataResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_bundle_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.bundle_id = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cstarglyphdata(cur_buf, tag_wiretype.wire_type)? +res.glyph_data << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstarreadglyphdataresponse() CStarreadGlyphDataResponse { +return CStarreadGlyphDataResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstarreadglyphdataresponse(o CStarreadGlyphDataResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstarreadglyphdataresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CStarreadGlyphDataResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstarreadglyphdataresponse_unpack(v)? +return i, unpacked +} +pub struct CStarwriteGlyphDataResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +result []EStarglyphWriteResult +} +pub fn (o &CStarwriteGlyphDataResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.result { +res << zzz_vproto_internal_pack_estarglyphwriteresult(x, 1) +} + +return res +} + +pub fn cstarwriteglyphdataresponse_unpack(buf []byte) ?CStarwriteGlyphDataResponse { +mut res := CStarwriteGlyphDataResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_estarglyphwriteresult(cur_buf, tag_wiretype.wire_type)? +res.result << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstarwriteglyphdataresponse() CStarwriteGlyphDataResponse { +return CStarwriteGlyphDataResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstarwriteglyphdataresponse(o CStarwriteGlyphDataResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstarwriteglyphdataresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CStarwriteGlyphDataResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstarwriteglyphdataresponse_unpack(v)? +return i, unpacked +} +pub struct CStarresponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +read_glyph_data CStarreadGlyphDataResponse +has_read_glyph_data bool +write_glyph_data CStarwriteGlyphDataResponse +has_write_glyph_data bool +} +pub fn (o &CStarresponse) pack() []byte { +mut res := []byte{} +if o.has_read_glyph_data { +res << zzz_vproto_internal_pack_cstarreadglyphdataresponse(o.read_glyph_data, 1) +} + +if o.has_write_glyph_data { +res << zzz_vproto_internal_pack_cstarwriteglyphdataresponse(o.write_glyph_data, 2) +} + +return res +} + +pub fn cstarresponse_unpack(buf []byte) ?CStarresponse { +mut res := CStarresponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_read_glyph_data = true +ii, v := zzz_vproto_internal_unpack_cstarreadglyphdataresponse(cur_buf, tag_wiretype.wire_type)? +res.read_glyph_data = v +i = ii +} + +2 { +res.has_write_glyph_data = true +ii, v := zzz_vproto_internal_unpack_cstarwriteglyphdataresponse(cur_buf, tag_wiretype.wire_type)? +res.write_glyph_data = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstarresponse() CStarresponse { +return CStarresponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstarresponse(o CStarresponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstarresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CStarresponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstarresponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_store.steamclient_pb.v b/proto/steammessages_store.steamclient_pb.v new file mode 100644 index 0000000..386350d --- /dev/null +++ b/proto/steammessages_store.steamclient_pb.v @@ -0,0 +1,890 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +[_allow_multiple_values] +enum EUserReviewScorePreference { +k_euserreviewscorepreference_unset = 0 +k_euserreviewscorepreference_includeall = 1 +k_euserreviewscorepreference_excludebombs = 2 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_euserreviewscorepreference(e EUserReviewScorePreference, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_euserreviewscorepreference(buf []byte, tag_wiretype vproto.WireType) ?(int, EUserReviewScorePreference) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EUserReviewScorePreference(v) +} +pub struct CStoreGetLocalizedNameForTagsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +language string +has_language bool +tagids []u32 +} +pub fn (o &CStoreGetLocalizedNameForTagsRequest) pack() []byte { +mut res := []byte{} +if o.has_language { +res << vproto.pack_string_field(o.language, 1) +} + +// [packed=false] +for _, x in o.tagids { +res << vproto.pack_uint32_field(x, 2) +} + +return res +} + +pub fn cstoregetlocalizednamefortagsrequest_unpack(buf []byte) ?CStoreGetLocalizedNameForTagsRequest { +mut res := CStoreGetLocalizedNameForTagsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_language = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.language = v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.tagids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstoregetlocalizednamefortagsrequest() CStoreGetLocalizedNameForTagsRequest { +return CStoreGetLocalizedNameForTagsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstoregetlocalizednamefortagsrequest(o CStoreGetLocalizedNameForTagsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstoregetlocalizednamefortagsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CStoreGetLocalizedNameForTagsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstoregetlocalizednamefortagsrequest_unpack(v)? +return i, unpacked +} +pub struct CStoreGetLocalizedNameForTagsResponseTag { +mut: +unknown_fields []vproto.UnknownField +pub mut: +tagid u32 +has_tagid bool +english_name string +has_english_name bool +name string +has_name bool +} +pub fn (o &CStoreGetLocalizedNameForTagsResponseTag) pack() []byte { +mut res := []byte{} +if o.has_tagid { +res << vproto.pack_uint32_field(o.tagid, 1) +} + +if o.has_english_name { +res << vproto.pack_string_field(o.english_name, 2) +} + +if o.has_name { +res << vproto.pack_string_field(o.name, 3) +} + +return res +} + +pub fn cstoregetlocalizednamefortagsresponsetag_unpack(buf []byte) ?CStoreGetLocalizedNameForTagsResponseTag { +mut res := CStoreGetLocalizedNameForTagsResponseTag{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_tagid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.tagid = v +i = ii +} + +2 { +res.has_english_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.english_name = v +i = ii +} + +3 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstoregetlocalizednamefortagsresponsetag() CStoreGetLocalizedNameForTagsResponseTag { +return CStoreGetLocalizedNameForTagsResponseTag{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstoregetlocalizednamefortagsresponsetag(o CStoreGetLocalizedNameForTagsResponseTag, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstoregetlocalizednamefortagsresponsetag(buf []byte, tag_wiretype vproto.WireType) ?(int, CStoreGetLocalizedNameForTagsResponseTag) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstoregetlocalizednamefortagsresponsetag_unpack(v)? +return i, unpacked +} +pub struct CStoreGetLocalizedNameForTagsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +tags []CStoreGetLocalizedNameForTagsResponseTag +} +pub fn (o &CStoreGetLocalizedNameForTagsResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.tags { +res << zzz_vproto_internal_pack_cstoregetlocalizednamefortagsresponsetag(x, 1) +} + +return res +} + +pub fn cstoregetlocalizednamefortagsresponse_unpack(buf []byte) ?CStoreGetLocalizedNameForTagsResponse { +mut res := CStoreGetLocalizedNameForTagsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cstoregetlocalizednamefortagsresponsetag(cur_buf, tag_wiretype.wire_type)? +res.tags << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstoregetlocalizednamefortagsresponse() CStoreGetLocalizedNameForTagsResponse { +return CStoreGetLocalizedNameForTagsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstoregetlocalizednamefortagsresponse(o CStoreGetLocalizedNameForTagsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstoregetlocalizednamefortagsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CStoreGetLocalizedNameForTagsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstoregetlocalizednamefortagsresponse_unpack(v)? +return i, unpacked +} +pub struct CStoreGetStorePreferencesRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CStoreGetStorePreferencesRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn cstoregetstorepreferencesrequest_unpack(buf []byte) ?CStoreGetStorePreferencesRequest { +res := CStoreGetStorePreferencesRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstoregetstorepreferencesrequest() CStoreGetStorePreferencesRequest { +return CStoreGetStorePreferencesRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstoregetstorepreferencesrequest(o CStoreGetStorePreferencesRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstoregetstorepreferencesrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CStoreGetStorePreferencesRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstoregetstorepreferencesrequest_unpack(v)? +return i, unpacked +} +pub struct CStoreUserPreferences { +mut: +unknown_fields []vproto.UnknownField +pub mut: +primary_language u32 +has_primary_language bool +secondary_languages u32 +has_secondary_languages bool +platform_windows bool +has_platform_windows bool +platform_mac bool +has_platform_mac bool +platform_linux bool +has_platform_linux bool +hide_adult_content_violence bool +has_hide_adult_content_violence bool +hide_adult_content_sex bool +has_hide_adult_content_sex bool +timestamp_updated u32 +has_timestamp_updated bool +hide_store_broadcast bool +has_hide_store_broadcast bool +review_score_preference EUserReviewScorePreference +has_review_score_preference bool +timestamp_content_descriptor_preferences_updated int +has_timestamp_content_descriptor_preferences_updated bool +} +pub fn (o &CStoreUserPreferences) pack() []byte { +mut res := []byte{} +if o.has_primary_language { +res << vproto.pack_uint32_field(o.primary_language, 1) +} + +if o.has_secondary_languages { +res << vproto.pack_uint32_field(o.secondary_languages, 2) +} + +if o.has_platform_windows { +res << vproto.pack_bool_field(o.platform_windows, 3) +} + +if o.has_platform_mac { +res << vproto.pack_bool_field(o.platform_mac, 4) +} + +if o.has_platform_linux { +res << vproto.pack_bool_field(o.platform_linux, 5) +} + +if o.has_hide_adult_content_violence { +res << vproto.pack_bool_field(o.hide_adult_content_violence, 6) +} + +if o.has_hide_adult_content_sex { +res << vproto.pack_bool_field(o.hide_adult_content_sex, 7) +} + +if o.has_timestamp_updated { +res << vproto.pack_uint32_field(o.timestamp_updated, 8) +} + +if o.has_hide_store_broadcast { +res << vproto.pack_bool_field(o.hide_store_broadcast, 9) +} + +if o.has_review_score_preference { +res << zzz_vproto_internal_pack_euserreviewscorepreference(o.review_score_preference, 10) +} + +if o.has_timestamp_content_descriptor_preferences_updated { +res << vproto.pack_int32_field(o.timestamp_content_descriptor_preferences_updated, 11) +} + +return res +} + +pub fn cstoreuserpreferences_unpack(buf []byte) ?CStoreUserPreferences { +mut res := CStoreUserPreferences{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_primary_language = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.primary_language = v +i = ii +} + +2 { +res.has_secondary_languages = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.secondary_languages = v +i = ii +} + +3 { +res.has_platform_windows = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.platform_windows = v +i = ii +} + +4 { +res.has_platform_mac = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.platform_mac = v +i = ii +} + +5 { +res.has_platform_linux = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.platform_linux = v +i = ii +} + +6 { +res.has_hide_adult_content_violence = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.hide_adult_content_violence = v +i = ii +} + +7 { +res.has_hide_adult_content_sex = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.hide_adult_content_sex = v +i = ii +} + +8 { +res.has_timestamp_updated = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp_updated = v +i = ii +} + +9 { +res.has_hide_store_broadcast = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.hide_store_broadcast = v +i = ii +} + +10 { +res.has_review_score_preference = true +ii, v := zzz_vproto_internal_unpack_euserreviewscorepreference(cur_buf, tag_wiretype.wire_type)? +res.review_score_preference = v +i = ii +} + +11 { +res.has_timestamp_content_descriptor_preferences_updated = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp_content_descriptor_preferences_updated = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstoreuserpreferences() CStoreUserPreferences { +return CStoreUserPreferences{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstoreuserpreferences(o CStoreUserPreferences, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstoreuserpreferences(buf []byte, tag_wiretype vproto.WireType) ?(int, CStoreUserPreferences) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstoreuserpreferences_unpack(v)? +return i, unpacked +} +pub struct CStoreUserTagPreferencesTag { +mut: +unknown_fields []vproto.UnknownField +pub mut: +tagid u32 +has_tagid bool +name string +has_name bool +timestamp_added u32 +has_timestamp_added bool +} +pub fn (o &CStoreUserTagPreferencesTag) pack() []byte { +mut res := []byte{} +if o.has_tagid { +res << vproto.pack_uint32_field(o.tagid, 1) +} + +if o.has_name { +res << vproto.pack_string_field(o.name, 2) +} + +if o.has_timestamp_added { +res << vproto.pack_uint32_field(o.timestamp_added, 3) +} + +return res +} + +pub fn cstoreusertagpreferencestag_unpack(buf []byte) ?CStoreUserTagPreferencesTag { +mut res := CStoreUserTagPreferencesTag{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_tagid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.tagid = v +i = ii +} + +2 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +3 { +res.has_timestamp_added = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp_added = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstoreusertagpreferencestag() CStoreUserTagPreferencesTag { +return CStoreUserTagPreferencesTag{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstoreusertagpreferencestag(o CStoreUserTagPreferencesTag, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstoreusertagpreferencestag(buf []byte, tag_wiretype vproto.WireType) ?(int, CStoreUserTagPreferencesTag) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstoreusertagpreferencestag_unpack(v)? +return i, unpacked +} +pub struct CStoreUserTagPreferences { +mut: +unknown_fields []vproto.UnknownField +pub mut: +tags_to_exclude []CStoreUserTagPreferencesTag +} +pub fn (o &CStoreUserTagPreferences) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.tags_to_exclude { +res << zzz_vproto_internal_pack_cstoreusertagpreferencestag(x, 1) +} + +return res +} + +pub fn cstoreusertagpreferences_unpack(buf []byte) ?CStoreUserTagPreferences { +mut res := CStoreUserTagPreferences{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cstoreusertagpreferencestag(cur_buf, tag_wiretype.wire_type)? +res.tags_to_exclude << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstoreusertagpreferences() CStoreUserTagPreferences { +return CStoreUserTagPreferences{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstoreusertagpreferences(o CStoreUserTagPreferences, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstoreusertagpreferences(buf []byte, tag_wiretype vproto.WireType) ?(int, CStoreUserTagPreferences) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstoreusertagpreferences_unpack(v)? +return i, unpacked +} +pub struct CStoreUserContentDescriptorPreferencesContentDescriptor { +mut: +unknown_fields []vproto.UnknownField +pub mut: +content_descriptorid u32 +has_content_descriptorid bool +timestamp_added u32 +has_timestamp_added bool +} +pub fn (o &CStoreUserContentDescriptorPreferencesContentDescriptor) pack() []byte { +mut res := []byte{} +if o.has_content_descriptorid { +res << vproto.pack_uint32_field(o.content_descriptorid, 1) +} + +if o.has_timestamp_added { +res << vproto.pack_uint32_field(o.timestamp_added, 2) +} + +return res +} + +pub fn cstoreusercontentdescriptorpreferencescontentdescriptor_unpack(buf []byte) ?CStoreUserContentDescriptorPreferencesContentDescriptor { +mut res := CStoreUserContentDescriptorPreferencesContentDescriptor{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_content_descriptorid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.content_descriptorid = v +i = ii +} + +2 { +res.has_timestamp_added = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp_added = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstoreusercontentdescriptorpreferencescontentdescriptor() CStoreUserContentDescriptorPreferencesContentDescriptor { +return CStoreUserContentDescriptorPreferencesContentDescriptor{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstoreusercontentdescriptorpreferencescontentdescriptor(o CStoreUserContentDescriptorPreferencesContentDescriptor, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstoreusercontentdescriptorpreferencescontentdescriptor(buf []byte, tag_wiretype vproto.WireType) ?(int, CStoreUserContentDescriptorPreferencesContentDescriptor) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstoreusercontentdescriptorpreferencescontentdescriptor_unpack(v)? +return i, unpacked +} +pub struct CStoreUserContentDescriptorPreferences { +mut: +unknown_fields []vproto.UnknownField +pub mut: +content_descriptors_to_exclude []CStoreUserContentDescriptorPreferencesContentDescriptor +} +pub fn (o &CStoreUserContentDescriptorPreferences) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.content_descriptors_to_exclude { +res << zzz_vproto_internal_pack_cstoreusercontentdescriptorpreferencescontentdescriptor(x, 1) +} + +return res +} + +pub fn cstoreusercontentdescriptorpreferences_unpack(buf []byte) ?CStoreUserContentDescriptorPreferences { +mut res := CStoreUserContentDescriptorPreferences{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cstoreusercontentdescriptorpreferencescontentdescriptor(cur_buf, tag_wiretype.wire_type)? +res.content_descriptors_to_exclude << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstoreusercontentdescriptorpreferences() CStoreUserContentDescriptorPreferences { +return CStoreUserContentDescriptorPreferences{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstoreusercontentdescriptorpreferences(o CStoreUserContentDescriptorPreferences, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstoreusercontentdescriptorpreferences(buf []byte, tag_wiretype vproto.WireType) ?(int, CStoreUserContentDescriptorPreferences) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstoreusercontentdescriptorpreferences_unpack(v)? +return i, unpacked +} +pub struct CStoreGetStorePreferencesResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +preferences CStoreUserPreferences +has_preferences bool +tag_preferences CStoreUserTagPreferences +has_tag_preferences bool +content_descriptor_preferences CStoreUserContentDescriptorPreferences +has_content_descriptor_preferences bool +} +pub fn (o &CStoreGetStorePreferencesResponse) pack() []byte { +mut res := []byte{} +if o.has_preferences { +res << zzz_vproto_internal_pack_cstoreuserpreferences(o.preferences, 1) +} + +if o.has_tag_preferences { +res << zzz_vproto_internal_pack_cstoreusertagpreferences(o.tag_preferences, 2) +} + +if o.has_content_descriptor_preferences { +res << zzz_vproto_internal_pack_cstoreusercontentdescriptorpreferences(o.content_descriptor_preferences, 3) +} + +return res +} + +pub fn cstoregetstorepreferencesresponse_unpack(buf []byte) ?CStoreGetStorePreferencesResponse { +mut res := CStoreGetStorePreferencesResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_preferences = true +ii, v := zzz_vproto_internal_unpack_cstoreuserpreferences(cur_buf, tag_wiretype.wire_type)? +res.preferences = v +i = ii +} + +2 { +res.has_tag_preferences = true +ii, v := zzz_vproto_internal_unpack_cstoreusertagpreferences(cur_buf, tag_wiretype.wire_type)? +res.tag_preferences = v +i = ii +} + +3 { +res.has_content_descriptor_preferences = true +ii, v := zzz_vproto_internal_unpack_cstoreusercontentdescriptorpreferences(cur_buf, tag_wiretype.wire_type)? +res.content_descriptor_preferences = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstoregetstorepreferencesresponse() CStoreGetStorePreferencesResponse { +return CStoreGetStorePreferencesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstoregetstorepreferencesresponse(o CStoreGetStorePreferencesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstoregetstorepreferencesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CStoreGetStorePreferencesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstoregetstorepreferencesresponse_unpack(v)? +return i, unpacked +} +pub struct CStoreStorePreferencesChangedNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +preferences CStoreUserPreferences +has_preferences bool +tag_preferences CStoreUserTagPreferences +has_tag_preferences bool +content_descriptor_preferences CStoreUserContentDescriptorPreferences +has_content_descriptor_preferences bool +} +pub fn (o &CStoreStorePreferencesChangedNotification) pack() []byte { +mut res := []byte{} +if o.has_preferences { +res << zzz_vproto_internal_pack_cstoreuserpreferences(o.preferences, 1) +} + +if o.has_tag_preferences { +res << zzz_vproto_internal_pack_cstoreusertagpreferences(o.tag_preferences, 2) +} + +if o.has_content_descriptor_preferences { +res << zzz_vproto_internal_pack_cstoreusercontentdescriptorpreferences(o.content_descriptor_preferences, 3) +} + +return res +} + +pub fn cstorestorepreferenceschangednotification_unpack(buf []byte) ?CStoreStorePreferencesChangedNotification { +mut res := CStoreStorePreferencesChangedNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_preferences = true +ii, v := zzz_vproto_internal_unpack_cstoreuserpreferences(cur_buf, tag_wiretype.wire_type)? +res.preferences = v +i = ii +} + +2 { +res.has_tag_preferences = true +ii, v := zzz_vproto_internal_unpack_cstoreusertagpreferences(cur_buf, tag_wiretype.wire_type)? +res.tag_preferences = v +i = ii +} + +3 { +res.has_content_descriptor_preferences = true +ii, v := zzz_vproto_internal_unpack_cstoreusercontentdescriptorpreferences(cur_buf, tag_wiretype.wire_type)? +res.content_descriptor_preferences = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstorestorepreferenceschangednotification() CStoreStorePreferencesChangedNotification { +return CStoreStorePreferencesChangedNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstorestorepreferenceschangednotification(o CStoreStorePreferencesChangedNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstorestorepreferenceschangednotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CStoreStorePreferencesChangedNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstorestorepreferenceschangednotification_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_timedtrial.steamclient_pb.v b/proto/steammessages_timedtrial.steamclient_pb.v new file mode 100644 index 0000000..587ea2f --- /dev/null +++ b/proto/steammessages_timedtrial.steamclient_pb.v @@ -0,0 +1,407 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CTimedTrialGetTimeRemainingRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +} +pub fn (o &CTimedTrialGetTimeRemainingRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +return res +} + +pub fn ctimedtrialgettimeremainingrequest_unpack(buf []byte) ?CTimedTrialGetTimeRemainingRequest { +mut res := CTimedTrialGetTimeRemainingRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctimedtrialgettimeremainingrequest() CTimedTrialGetTimeRemainingRequest { +return CTimedTrialGetTimeRemainingRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctimedtrialgettimeremainingrequest(o CTimedTrialGetTimeRemainingRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctimedtrialgettimeremainingrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CTimedTrialGetTimeRemainingRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctimedtrialgettimeremainingrequest_unpack(v)? +return i, unpacked +} +pub struct CTimedTrialGetTimeRemainingResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +seconds_played u32 +has_seconds_played bool +seconds_allowed u32 +has_seconds_allowed bool +} +pub fn (o &CTimedTrialGetTimeRemainingResponse) pack() []byte { +mut res := []byte{} +if o.has_seconds_played { +res << vproto.pack_uint32_field(o.seconds_played, 1) +} + +if o.has_seconds_allowed { +res << vproto.pack_uint32_field(o.seconds_allowed, 2) +} + +return res +} + +pub fn ctimedtrialgettimeremainingresponse_unpack(buf []byte) ?CTimedTrialGetTimeRemainingResponse { +mut res := CTimedTrialGetTimeRemainingResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_seconds_played = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_played = v +i = ii +} + +2 { +res.has_seconds_allowed = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_allowed = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctimedtrialgettimeremainingresponse() CTimedTrialGetTimeRemainingResponse { +return CTimedTrialGetTimeRemainingResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctimedtrialgettimeremainingresponse(o CTimedTrialGetTimeRemainingResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctimedtrialgettimeremainingresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CTimedTrialGetTimeRemainingResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctimedtrialgettimeremainingresponse_unpack(v)? +return i, unpacked +} +pub struct CTimedTrialRecordPlaytimeRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +seconds_played u32 +has_seconds_played bool +} +pub fn (o &CTimedTrialRecordPlaytimeRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_seconds_played { +res << vproto.pack_uint32_field(o.seconds_played, 2) +} + +return res +} + +pub fn ctimedtrialrecordplaytimerequest_unpack(buf []byte) ?CTimedTrialRecordPlaytimeRequest { +mut res := CTimedTrialRecordPlaytimeRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_seconds_played = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_played = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctimedtrialrecordplaytimerequest() CTimedTrialRecordPlaytimeRequest { +return CTimedTrialRecordPlaytimeRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctimedtrialrecordplaytimerequest(o CTimedTrialRecordPlaytimeRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctimedtrialrecordplaytimerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CTimedTrialRecordPlaytimeRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctimedtrialrecordplaytimerequest_unpack(v)? +return i, unpacked +} +pub struct CTimedTrialRecordPlaytimeResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +seconds_played u32 +has_seconds_played bool +seconds_allowed u32 +has_seconds_allowed bool +} +pub fn (o &CTimedTrialRecordPlaytimeResponse) pack() []byte { +mut res := []byte{} +if o.has_seconds_played { +res << vproto.pack_uint32_field(o.seconds_played, 1) +} + +if o.has_seconds_allowed { +res << vproto.pack_uint32_field(o.seconds_allowed, 2) +} + +return res +} + +pub fn ctimedtrialrecordplaytimeresponse_unpack(buf []byte) ?CTimedTrialRecordPlaytimeResponse { +mut res := CTimedTrialRecordPlaytimeResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_seconds_played = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_played = v +i = ii +} + +2 { +res.has_seconds_allowed = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_allowed = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctimedtrialrecordplaytimeresponse() CTimedTrialRecordPlaytimeResponse { +return CTimedTrialRecordPlaytimeResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctimedtrialrecordplaytimeresponse(o CTimedTrialRecordPlaytimeResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctimedtrialrecordplaytimeresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CTimedTrialRecordPlaytimeResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctimedtrialrecordplaytimeresponse_unpack(v)? +return i, unpacked +} +pub struct CTimedTrialResetPlaytimeRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +} +pub fn (o &CTimedTrialResetPlaytimeRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +return res +} + +pub fn ctimedtrialresetplaytimerequest_unpack(buf []byte) ?CTimedTrialResetPlaytimeRequest { +mut res := CTimedTrialResetPlaytimeRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctimedtrialresetplaytimerequest() CTimedTrialResetPlaytimeRequest { +return CTimedTrialResetPlaytimeRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctimedtrialresetplaytimerequest(o CTimedTrialResetPlaytimeRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctimedtrialresetplaytimerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CTimedTrialResetPlaytimeRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctimedtrialresetplaytimerequest_unpack(v)? +return i, unpacked +} +pub struct CTimedTrialResetPlaytimeResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +seconds_played u32 +has_seconds_played bool +seconds_allowed u32 +has_seconds_allowed bool +} +pub fn (o &CTimedTrialResetPlaytimeResponse) pack() []byte { +mut res := []byte{} +if o.has_seconds_played { +res << vproto.pack_uint32_field(o.seconds_played, 1) +} + +if o.has_seconds_allowed { +res << vproto.pack_uint32_field(o.seconds_allowed, 2) +} + +return res +} + +pub fn ctimedtrialresetplaytimeresponse_unpack(buf []byte) ?CTimedTrialResetPlaytimeResponse { +mut res := CTimedTrialResetPlaytimeResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_seconds_played = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_played = v +i = ii +} + +2 { +res.has_seconds_allowed = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.seconds_allowed = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctimedtrialresetplaytimeresponse() CTimedTrialResetPlaytimeResponse { +return CTimedTrialResetPlaytimeResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctimedtrialresetplaytimeresponse(o CTimedTrialResetPlaytimeResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctimedtrialresetplaytimeresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CTimedTrialResetPlaytimeResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctimedtrialresetplaytimeresponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_twofactor.steamclient_pb.v b/proto/steammessages_twofactor.steamclient_pb.v new file mode 100644 index 0000000..f9c2bdb --- /dev/null +++ b/proto/steammessages_twofactor.steamclient_pb.v @@ -0,0 +1,1408 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CTwoFactorStatusRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +} +pub fn (o &CTwoFactorStatusRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +return res +} + +pub fn ctwofactorstatusrequest_unpack(buf []byte) ?CTwoFactorStatusRequest { +mut res := CTwoFactorStatusRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctwofactorstatusrequest() CTwoFactorStatusRequest { +return CTwoFactorStatusRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctwofactorstatusrequest(o CTwoFactorStatusRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctwofactorstatusrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CTwoFactorStatusRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctwofactorstatusrequest_unpack(v)? +return i, unpacked +} +pub struct CTwoFactorStatusResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +state u32 +has_state bool +inactivation_reason u32 +has_inactivation_reason bool +authenticator_type u32 +has_authenticator_type bool +authenticator_allowed bool +has_authenticator_allowed bool +steamguard_scheme u32 +has_steamguard_scheme bool +token_gid string +has_token_gid bool +email_validated bool +has_email_validated bool +device_identifier string +has_device_identifier bool +time_created u32 +has_time_created bool +revocation_attempts_remaining u32 +has_revocation_attempts_remaining bool +classified_agent string +has_classified_agent bool +allow_external_authenticator bool +has_allow_external_authenticator bool +time_transferred u32 +has_time_transferred bool +} +pub fn (o &CTwoFactorStatusResponse) pack() []byte { +mut res := []byte{} +if o.has_state { +res << vproto.pack_uint32_field(o.state, 1) +} + +if o.has_inactivation_reason { +res << vproto.pack_uint32_field(o.inactivation_reason, 2) +} + +if o.has_authenticator_type { +res << vproto.pack_uint32_field(o.authenticator_type, 3) +} + +if o.has_authenticator_allowed { +res << vproto.pack_bool_field(o.authenticator_allowed, 4) +} + +if o.has_steamguard_scheme { +res << vproto.pack_uint32_field(o.steamguard_scheme, 5) +} + +if o.has_token_gid { +res << vproto.pack_string_field(o.token_gid, 6) +} + +if o.has_email_validated { +res << vproto.pack_bool_field(o.email_validated, 7) +} + +if o.has_device_identifier { +res << vproto.pack_string_field(o.device_identifier, 8) +} + +if o.has_time_created { +res << vproto.pack_uint32_field(o.time_created, 9) +} + +if o.has_revocation_attempts_remaining { +res << vproto.pack_uint32_field(o.revocation_attempts_remaining, 10) +} + +if o.has_classified_agent { +res << vproto.pack_string_field(o.classified_agent, 11) +} + +if o.has_allow_external_authenticator { +res << vproto.pack_bool_field(o.allow_external_authenticator, 12) +} + +if o.has_time_transferred { +res << vproto.pack_uint32_field(o.time_transferred, 13) +} + +return res +} + +pub fn ctwofactorstatusresponse_unpack(buf []byte) ?CTwoFactorStatusResponse { +mut res := CTwoFactorStatusResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_state = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.state = v +i = ii +} + +2 { +res.has_inactivation_reason = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.inactivation_reason = v +i = ii +} + +3 { +res.has_authenticator_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.authenticator_type = v +i = ii +} + +4 { +res.has_authenticator_allowed = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.authenticator_allowed = v +i = ii +} + +5 { +res.has_steamguard_scheme = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.steamguard_scheme = v +i = ii +} + +6 { +res.has_token_gid = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.token_gid = v +i = ii +} + +7 { +res.has_email_validated = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.email_validated = v +i = ii +} + +8 { +res.has_device_identifier = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.device_identifier = v +i = ii +} + +9 { +res.has_time_created = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_created = v +i = ii +} + +10 { +res.has_revocation_attempts_remaining = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.revocation_attempts_remaining = v +i = ii +} + +11 { +res.has_classified_agent = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.classified_agent = v +i = ii +} + +12 { +res.has_allow_external_authenticator = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.allow_external_authenticator = v +i = ii +} + +13 { +res.has_time_transferred = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.time_transferred = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctwofactorstatusresponse() CTwoFactorStatusResponse { +return CTwoFactorStatusResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctwofactorstatusresponse(o CTwoFactorStatusResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctwofactorstatusresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CTwoFactorStatusResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctwofactorstatusresponse_unpack(v)? +return i, unpacked +} +pub struct CTwoFactorAddAuthenticatorRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +authenticator_time u64 +has_authenticator_time bool +serial_number u64 +has_serial_number bool +authenticator_type u32 +has_authenticator_type bool +device_identifier string +has_device_identifier bool +sms_phone_id string +has_sms_phone_id bool +http_headers []string +} +pub fn (o &CTwoFactorAddAuthenticatorRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_authenticator_time { +res << vproto.pack_uint64_field(o.authenticator_time, 2) +} + +if o.has_serial_number { +res << vproto.pack_64bit_field(o.serial_number, 3) +} + +if o.has_authenticator_type { +res << vproto.pack_uint32_field(o.authenticator_type, 4) +} + +if o.has_device_identifier { +res << vproto.pack_string_field(o.device_identifier, 5) +} + +if o.has_sms_phone_id { +res << vproto.pack_string_field(o.sms_phone_id, 6) +} + +// [packed=false] +for _, x in o.http_headers { +res << vproto.pack_string_field(x, 7) +} + +return res +} + +pub fn ctwofactoraddauthenticatorrequest_unpack(buf []byte) ?CTwoFactorAddAuthenticatorRequest { +mut res := CTwoFactorAddAuthenticatorRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_authenticator_time = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.authenticator_time = v +i = ii +} + +3 { +res.has_serial_number = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.serial_number = v +i = ii +} + +4 { +res.has_authenticator_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.authenticator_type = v +i = ii +} + +5 { +res.has_device_identifier = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.device_identifier = v +i = ii +} + +6 { +res.has_sms_phone_id = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.sms_phone_id = v +i = ii +} + +7 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.http_headers << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctwofactoraddauthenticatorrequest() CTwoFactorAddAuthenticatorRequest { +return CTwoFactorAddAuthenticatorRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctwofactoraddauthenticatorrequest(o CTwoFactorAddAuthenticatorRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctwofactoraddauthenticatorrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CTwoFactorAddAuthenticatorRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctwofactoraddauthenticatorrequest_unpack(v)? +return i, unpacked +} +pub struct CTwoFactorAddAuthenticatorResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +shared_secret []byte +has_shared_secret bool +serial_number u64 +has_serial_number bool +revocation_code string +has_revocation_code bool +uri string +has_uri bool +server_time u64 +has_server_time bool +account_name string +has_account_name bool +token_gid string +has_token_gid bool +identity_secret []byte +has_identity_secret bool +secret_1 []byte +has_secret_1 bool +status int +has_status bool +} +pub fn (o &CTwoFactorAddAuthenticatorResponse) pack() []byte { +mut res := []byte{} +if o.has_shared_secret { +res << vproto.pack_bytes_field(o.shared_secret, 1) +} + +if o.has_serial_number { +res << vproto.pack_64bit_field(o.serial_number, 2) +} + +if o.has_revocation_code { +res << vproto.pack_string_field(o.revocation_code, 3) +} + +if o.has_uri { +res << vproto.pack_string_field(o.uri, 4) +} + +if o.has_server_time { +res << vproto.pack_uint64_field(o.server_time, 5) +} + +if o.has_account_name { +res << vproto.pack_string_field(o.account_name, 6) +} + +if o.has_token_gid { +res << vproto.pack_string_field(o.token_gid, 7) +} + +if o.has_identity_secret { +res << vproto.pack_bytes_field(o.identity_secret, 8) +} + +if o.has_secret_1 { +res << vproto.pack_bytes_field(o.secret_1, 9) +} + +if o.has_status { +res << vproto.pack_int32_field(o.status, 10) +} + +return res +} + +pub fn ctwofactoraddauthenticatorresponse_unpack(buf []byte) ?CTwoFactorAddAuthenticatorResponse { +mut res := CTwoFactorAddAuthenticatorResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_shared_secret = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.shared_secret = v +i = ii +} + +2 { +res.has_serial_number = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.serial_number = v +i = ii +} + +3 { +res.has_revocation_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.revocation_code = v +i = ii +} + +4 { +res.has_uri = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.uri = v +i = ii +} + +5 { +res.has_server_time = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.server_time = v +i = ii +} + +6 { +res.has_account_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.account_name = v +i = ii +} + +7 { +res.has_token_gid = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.token_gid = v +i = ii +} + +8 { +res.has_identity_secret = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.identity_secret = v +i = ii +} + +9 { +res.has_secret_1 = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.secret_1 = v +i = ii +} + +10 { +res.has_status = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.status = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctwofactoraddauthenticatorresponse() CTwoFactorAddAuthenticatorResponse { +return CTwoFactorAddAuthenticatorResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctwofactoraddauthenticatorresponse(o CTwoFactorAddAuthenticatorResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctwofactoraddauthenticatorresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CTwoFactorAddAuthenticatorResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctwofactoraddauthenticatorresponse_unpack(v)? +return i, unpacked +} +pub struct CTwoFactorSendEmailRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +email_type u32 +has_email_type bool +include_activation_code bool +has_include_activation_code bool +} +pub fn (o &CTwoFactorSendEmailRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_email_type { +res << vproto.pack_uint32_field(o.email_type, 2) +} + +if o.has_include_activation_code { +res << vproto.pack_bool_field(o.include_activation_code, 3) +} + +return res +} + +pub fn ctwofactorsendemailrequest_unpack(buf []byte) ?CTwoFactorSendEmailRequest { +mut res := CTwoFactorSendEmailRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_email_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.email_type = v +i = ii +} + +3 { +res.has_include_activation_code = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.include_activation_code = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctwofactorsendemailrequest() CTwoFactorSendEmailRequest { +return CTwoFactorSendEmailRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctwofactorsendemailrequest(o CTwoFactorSendEmailRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctwofactorsendemailrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CTwoFactorSendEmailRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctwofactorsendemailrequest_unpack(v)? +return i, unpacked +} +pub struct CTwoFactorSendEmailResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CTwoFactorSendEmailResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn ctwofactorsendemailresponse_unpack(buf []byte) ?CTwoFactorSendEmailResponse { +res := CTwoFactorSendEmailResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctwofactorsendemailresponse() CTwoFactorSendEmailResponse { +return CTwoFactorSendEmailResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctwofactorsendemailresponse(o CTwoFactorSendEmailResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctwofactorsendemailresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CTwoFactorSendEmailResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctwofactorsendemailresponse_unpack(v)? +return i, unpacked +} +pub struct CTwoFactorFinalizeAddAuthenticatorRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +authenticator_code string +has_authenticator_code bool +authenticator_time u64 +has_authenticator_time bool +activation_code string +has_activation_code bool +http_headers []string +} +pub fn (o &CTwoFactorFinalizeAddAuthenticatorRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_authenticator_code { +res << vproto.pack_string_field(o.authenticator_code, 2) +} + +if o.has_authenticator_time { +res << vproto.pack_uint64_field(o.authenticator_time, 3) +} + +if o.has_activation_code { +res << vproto.pack_string_field(o.activation_code, 4) +} + +// [packed=false] +for _, x in o.http_headers { +res << vproto.pack_string_field(x, 5) +} + +return res +} + +pub fn ctwofactorfinalizeaddauthenticatorrequest_unpack(buf []byte) ?CTwoFactorFinalizeAddAuthenticatorRequest { +mut res := CTwoFactorFinalizeAddAuthenticatorRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_authenticator_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.authenticator_code = v +i = ii +} + +3 { +res.has_authenticator_time = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.authenticator_time = v +i = ii +} + +4 { +res.has_activation_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.activation_code = v +i = ii +} + +5 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.http_headers << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctwofactorfinalizeaddauthenticatorrequest() CTwoFactorFinalizeAddAuthenticatorRequest { +return CTwoFactorFinalizeAddAuthenticatorRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctwofactorfinalizeaddauthenticatorrequest(o CTwoFactorFinalizeAddAuthenticatorRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctwofactorfinalizeaddauthenticatorrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CTwoFactorFinalizeAddAuthenticatorRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctwofactorfinalizeaddauthenticatorrequest_unpack(v)? +return i, unpacked +} +pub struct CTwoFactorFinalizeAddAuthenticatorResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +success bool +has_success bool +want_more bool +has_want_more bool +server_time u64 +has_server_time bool +status int +has_status bool +} +pub fn (o &CTwoFactorFinalizeAddAuthenticatorResponse) pack() []byte { +mut res := []byte{} +if o.has_success { +res << vproto.pack_bool_field(o.success, 1) +} + +if o.has_want_more { +res << vproto.pack_bool_field(o.want_more, 2) +} + +if o.has_server_time { +res << vproto.pack_uint64_field(o.server_time, 3) +} + +if o.has_status { +res << vproto.pack_int32_field(o.status, 4) +} + +return res +} + +pub fn ctwofactorfinalizeaddauthenticatorresponse_unpack(buf []byte) ?CTwoFactorFinalizeAddAuthenticatorResponse { +mut res := CTwoFactorFinalizeAddAuthenticatorResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_success = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.success = v +i = ii +} + +2 { +res.has_want_more = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.want_more = v +i = ii +} + +3 { +res.has_server_time = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.server_time = v +i = ii +} + +4 { +res.has_status = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.status = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctwofactorfinalizeaddauthenticatorresponse() CTwoFactorFinalizeAddAuthenticatorResponse { +return CTwoFactorFinalizeAddAuthenticatorResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctwofactorfinalizeaddauthenticatorresponse(o CTwoFactorFinalizeAddAuthenticatorResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctwofactorfinalizeaddauthenticatorresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CTwoFactorFinalizeAddAuthenticatorResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctwofactorfinalizeaddauthenticatorresponse_unpack(v)? +return i, unpacked +} +pub struct CTwoFactorRemoveAuthenticatorRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +revocation_code string +has_revocation_code bool +revocation_reason u32 +has_revocation_reason bool +steamguard_scheme u32 +has_steamguard_scheme bool +remove_all_steamguard_cookies bool +has_remove_all_steamguard_cookies bool +} +pub fn (o &CTwoFactorRemoveAuthenticatorRequest) pack() []byte { +mut res := []byte{} +if o.has_revocation_code { +res << vproto.pack_string_field(o.revocation_code, 2) +} + +if o.has_revocation_reason { +res << vproto.pack_uint32_field(o.revocation_reason, 5) +} + +if o.has_steamguard_scheme { +res << vproto.pack_uint32_field(o.steamguard_scheme, 6) +} + +if o.has_remove_all_steamguard_cookies { +res << vproto.pack_bool_field(o.remove_all_steamguard_cookies, 7) +} + +return res +} + +pub fn ctwofactorremoveauthenticatorrequest_unpack(buf []byte) ?CTwoFactorRemoveAuthenticatorRequest { +mut res := CTwoFactorRemoveAuthenticatorRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +2 { +res.has_revocation_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.revocation_code = v +i = ii +} + +5 { +res.has_revocation_reason = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.revocation_reason = v +i = ii +} + +6 { +res.has_steamguard_scheme = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.steamguard_scheme = v +i = ii +} + +7 { +res.has_remove_all_steamguard_cookies = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.remove_all_steamguard_cookies = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctwofactorremoveauthenticatorrequest() CTwoFactorRemoveAuthenticatorRequest { +return CTwoFactorRemoveAuthenticatorRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctwofactorremoveauthenticatorrequest(o CTwoFactorRemoveAuthenticatorRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctwofactorremoveauthenticatorrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CTwoFactorRemoveAuthenticatorRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctwofactorremoveauthenticatorrequest_unpack(v)? +return i, unpacked +} +pub struct CTwoFactorRemoveAuthenticatorResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +success bool +has_success bool +server_time u64 +has_server_time bool +revocation_attempts_remaining u32 +has_revocation_attempts_remaining bool +} +pub fn (o &CTwoFactorRemoveAuthenticatorResponse) pack() []byte { +mut res := []byte{} +if o.has_success { +res << vproto.pack_bool_field(o.success, 1) +} + +if o.has_server_time { +res << vproto.pack_uint64_field(o.server_time, 3) +} + +if o.has_revocation_attempts_remaining { +res << vproto.pack_uint32_field(o.revocation_attempts_remaining, 5) +} + +return res +} + +pub fn ctwofactorremoveauthenticatorresponse_unpack(buf []byte) ?CTwoFactorRemoveAuthenticatorResponse { +mut res := CTwoFactorRemoveAuthenticatorResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_success = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.success = v +i = ii +} + +3 { +res.has_server_time = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.server_time = v +i = ii +} + +5 { +res.has_revocation_attempts_remaining = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.revocation_attempts_remaining = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctwofactorremoveauthenticatorresponse() CTwoFactorRemoveAuthenticatorResponse { +return CTwoFactorRemoveAuthenticatorResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctwofactorremoveauthenticatorresponse(o CTwoFactorRemoveAuthenticatorResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctwofactorremoveauthenticatorresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CTwoFactorRemoveAuthenticatorResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctwofactorremoveauthenticatorresponse_unpack(v)? +return i, unpacked +} +pub struct CTwoFactorCreateEmergencyCodesRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +code string +has_code bool +} +pub fn (o &CTwoFactorCreateEmergencyCodesRequest) pack() []byte { +mut res := []byte{} +if o.has_code { +res << vproto.pack_string_field(o.code, 1) +} + +return res +} + +pub fn ctwofactorcreateemergencycodesrequest_unpack(buf []byte) ?CTwoFactorCreateEmergencyCodesRequest { +mut res := CTwoFactorCreateEmergencyCodesRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.code = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctwofactorcreateemergencycodesrequest() CTwoFactorCreateEmergencyCodesRequest { +return CTwoFactorCreateEmergencyCodesRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctwofactorcreateemergencycodesrequest(o CTwoFactorCreateEmergencyCodesRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctwofactorcreateemergencycodesrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CTwoFactorCreateEmergencyCodesRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctwofactorcreateemergencycodesrequest_unpack(v)? +return i, unpacked +} +pub struct CTwoFactorCreateEmergencyCodesResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +codes []string +} +pub fn (o &CTwoFactorCreateEmergencyCodesResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.codes { +res << vproto.pack_string_field(x, 1) +} + +return res +} + +pub fn ctwofactorcreateemergencycodesresponse_unpack(buf []byte) ?CTwoFactorCreateEmergencyCodesResponse { +mut res := CTwoFactorCreateEmergencyCodesResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.codes << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctwofactorcreateemergencycodesresponse() CTwoFactorCreateEmergencyCodesResponse { +return CTwoFactorCreateEmergencyCodesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctwofactorcreateemergencycodesresponse(o CTwoFactorCreateEmergencyCodesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctwofactorcreateemergencycodesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CTwoFactorCreateEmergencyCodesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctwofactorcreateemergencycodesresponse_unpack(v)? +return i, unpacked +} +pub struct CTwoFactorDestroyEmergencyCodesRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +} +pub fn (o &CTwoFactorDestroyEmergencyCodesRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +return res +} + +pub fn ctwofactordestroyemergencycodesrequest_unpack(buf []byte) ?CTwoFactorDestroyEmergencyCodesRequest { +mut res := CTwoFactorDestroyEmergencyCodesRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctwofactordestroyemergencycodesrequest() CTwoFactorDestroyEmergencyCodesRequest { +return CTwoFactorDestroyEmergencyCodesRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctwofactordestroyemergencycodesrequest(o CTwoFactorDestroyEmergencyCodesRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctwofactordestroyemergencycodesrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CTwoFactorDestroyEmergencyCodesRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctwofactordestroyemergencycodesrequest_unpack(v)? +return i, unpacked +} +pub struct CTwoFactorDestroyEmergencyCodesResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CTwoFactorDestroyEmergencyCodesResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn ctwofactordestroyemergencycodesresponse_unpack(buf []byte) ?CTwoFactorDestroyEmergencyCodesResponse { +res := CTwoFactorDestroyEmergencyCodesResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctwofactordestroyemergencycodesresponse() CTwoFactorDestroyEmergencyCodesResponse { +return CTwoFactorDestroyEmergencyCodesResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctwofactordestroyemergencycodesresponse(o CTwoFactorDestroyEmergencyCodesResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctwofactordestroyemergencycodesresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CTwoFactorDestroyEmergencyCodesResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctwofactordestroyemergencycodesresponse_unpack(v)? +return i, unpacked +} +pub struct CTwoFactorValidateTokenRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +code string +has_code bool +} +pub fn (o &CTwoFactorValidateTokenRequest) pack() []byte { +mut res := []byte{} +if o.has_code { +res << vproto.pack_string_field(o.code, 1) +} + +return res +} + +pub fn ctwofactorvalidatetokenrequest_unpack(buf []byte) ?CTwoFactorValidateTokenRequest { +mut res := CTwoFactorValidateTokenRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.code = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctwofactorvalidatetokenrequest() CTwoFactorValidateTokenRequest { +return CTwoFactorValidateTokenRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctwofactorvalidatetokenrequest(o CTwoFactorValidateTokenRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctwofactorvalidatetokenrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CTwoFactorValidateTokenRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctwofactorvalidatetokenrequest_unpack(v)? +return i, unpacked +} +pub struct CTwoFactorValidateTokenResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +valid bool +has_valid bool +} +pub fn (o &CTwoFactorValidateTokenResponse) pack() []byte { +mut res := []byte{} +if o.has_valid { +res << vproto.pack_bool_field(o.valid, 1) +} + +return res +} + +pub fn ctwofactorvalidatetokenresponse_unpack(buf []byte) ?CTwoFactorValidateTokenResponse { +mut res := CTwoFactorValidateTokenResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_valid = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.valid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctwofactorvalidatetokenresponse() CTwoFactorValidateTokenResponse { +return CTwoFactorValidateTokenResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctwofactorvalidatetokenresponse(o CTwoFactorValidateTokenResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctwofactorvalidatetokenresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CTwoFactorValidateTokenResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctwofactorvalidatetokenresponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_unified_base.steamclient_pb.v b/proto/steammessages_unified_base.steamclient_pb.v new file mode 100644 index 0000000..f1b0714 --- /dev/null +++ b/proto/steammessages_unified_base.steamclient_pb.v @@ -0,0 +1,50 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + +import proto.google.protobuf + +[_allow_multiple_values] +enum EProtoExecutionSite { +k_eprotoexecutionsiteunknown = 0 +k_eprotoexecutionsitesteamclient = 2 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_eprotoexecutionsite(e EProtoExecutionSite, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_eprotoexecutionsite(buf []byte, tag_wiretype vproto.WireType) ?(int, EProtoExecutionSite) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EProtoExecutionSite(v) +} +pub struct NoResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &NoResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn noresponse_unpack(buf []byte) ?NoResponse { +res := NoResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_noresponse() NoResponse { +return NoResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_noresponse(o NoResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_noresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, NoResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := noresponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_unified_test.steamclient_pb.v b/proto/steammessages_unified_test.steamclient_pb.v new file mode 100644 index 0000000..3680ff0 --- /dev/null +++ b/proto/steammessages_unified_test.steamclient_pb.v @@ -0,0 +1,355 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CMsgTestMessageToClientRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +some_text string +has_some_text bool +} +pub fn (o &CMsgTestMessageToClientRequest) pack() []byte { +mut res := []byte{} +if o.has_some_text { +res << vproto.pack_string_field(o.some_text, 1) +} + +return res +} + +pub fn cmsgtestmessagetoclientrequest_unpack(buf []byte) ?CMsgTestMessageToClientRequest { +mut res := CMsgTestMessageToClientRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_some_text = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.some_text = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgtestmessagetoclientrequest() CMsgTestMessageToClientRequest { +return CMsgTestMessageToClientRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgtestmessagetoclientrequest(o CMsgTestMessageToClientRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgtestmessagetoclientrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgTestMessageToClientRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgtestmessagetoclientrequest_unpack(v)? +return i, unpacked +} +pub struct CMsgTestMessageToClientResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +some_text string +has_some_text bool +} +pub fn (o &CMsgTestMessageToClientResponse) pack() []byte { +mut res := []byte{} +if o.has_some_text { +res << vproto.pack_string_field(o.some_text, 1) +} + +return res +} + +pub fn cmsgtestmessagetoclientresponse_unpack(buf []byte) ?CMsgTestMessageToClientResponse { +mut res := CMsgTestMessageToClientResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_some_text = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.some_text = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgtestmessagetoclientresponse() CMsgTestMessageToClientResponse { +return CMsgTestMessageToClientResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgtestmessagetoclientresponse(o CMsgTestMessageToClientResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgtestmessagetoclientresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgTestMessageToClientResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgtestmessagetoclientresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgTestNotifyClientNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +some_text string +has_some_text bool +} +pub fn (o &CMsgTestNotifyClientNotification) pack() []byte { +mut res := []byte{} +if o.has_some_text { +res << vproto.pack_string_field(o.some_text, 1) +} + +return res +} + +pub fn cmsgtestnotifyclientnotification_unpack(buf []byte) ?CMsgTestNotifyClientNotification { +mut res := CMsgTestNotifyClientNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_some_text = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.some_text = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgtestnotifyclientnotification() CMsgTestNotifyClientNotification { +return CMsgTestNotifyClientNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgtestnotifyclientnotification(o CMsgTestNotifyClientNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgtestnotifyclientnotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgTestNotifyClientNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgtestnotifyclientnotification_unpack(v)? +return i, unpacked +} +pub struct CMsgTestMessageToServerRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +some_text string +has_some_text bool +} +pub fn (o &CMsgTestMessageToServerRequest) pack() []byte { +mut res := []byte{} +if o.has_some_text { +res << vproto.pack_string_field(o.some_text, 1) +} + +return res +} + +pub fn cmsgtestmessagetoserverrequest_unpack(buf []byte) ?CMsgTestMessageToServerRequest { +mut res := CMsgTestMessageToServerRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_some_text = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.some_text = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgtestmessagetoserverrequest() CMsgTestMessageToServerRequest { +return CMsgTestMessageToServerRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgtestmessagetoserverrequest(o CMsgTestMessageToServerRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgtestmessagetoserverrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgTestMessageToServerRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgtestmessagetoserverrequest_unpack(v)? +return i, unpacked +} +pub struct CMsgTestMessageToServerResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +some_text string +has_some_text bool +} +pub fn (o &CMsgTestMessageToServerResponse) pack() []byte { +mut res := []byte{} +if o.has_some_text { +res << vproto.pack_string_field(o.some_text, 1) +} + +return res +} + +pub fn cmsgtestmessagetoserverresponse_unpack(buf []byte) ?CMsgTestMessageToServerResponse { +mut res := CMsgTestMessageToServerResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_some_text = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.some_text = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgtestmessagetoserverresponse() CMsgTestMessageToServerResponse { +return CMsgTestMessageToServerResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgtestmessagetoserverresponse(o CMsgTestMessageToServerResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgtestmessagetoserverresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgTestMessageToServerResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgtestmessagetoserverresponse_unpack(v)? +return i, unpacked +} +pub struct CMsgTestNotifyServerNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +some_text string +has_some_text bool +} +pub fn (o &CMsgTestNotifyServerNotification) pack() []byte { +mut res := []byte{} +if o.has_some_text { +res << vproto.pack_string_field(o.some_text, 1) +} + +return res +} + +pub fn cmsgtestnotifyservernotification_unpack(buf []byte) ?CMsgTestNotifyServerNotification { +mut res := CMsgTestNotifyServerNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_some_text = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.some_text = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgtestnotifyservernotification() CMsgTestNotifyServerNotification { +return CMsgTestNotifyServerNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgtestnotifyservernotification(o CMsgTestNotifyServerNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgtestnotifyservernotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgTestNotifyServerNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgtestnotifyservernotification_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_useraccount.steamclient_pb.v b/proto/steammessages_useraccount.steamclient_pb.v new file mode 100644 index 0000000..0256036 --- /dev/null +++ b/proto/steammessages_useraccount.steamclient_pb.v @@ -0,0 +1,1807 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +[_allow_multiple_values] +enum EInternalAccountType { +k_einternalsteamaccounttype = 1 +k_einternalclantype = 2 +k_einternalapptype = 3 +k_einternalbroadcastchanneltype = 4 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_einternalaccounttype(e EInternalAccountType, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_einternalaccounttype(buf []byte, tag_wiretype vproto.WireType) ?(int, EInternalAccountType) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EInternalAccountType(v) +} +[_allow_multiple_values] +enum EExternalAccountType { +k_eexternalnone = 0 +k_eexternalsteamaccount = 1 +k_eexternalgoogleaccount = 2 +k_eexternalfacebookaccount = 3 +k_eexternaltwitteraccount = 4 +k_eexternaltwitchaccount = 5 +k_eexternalyoutubechannelaccount = 6 +k_eexternalfacebookpage = 7 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_eexternalaccounttype(e EExternalAccountType, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_eexternalaccounttype(buf []byte, tag_wiretype vproto.WireType) ?(int, EExternalAccountType) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EExternalAccountType(v) +} +pub struct CUserAccountGetAvailableValveDiscountPromotionsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +country_code string +has_country_code bool +} +pub fn (o &CUserAccountGetAvailableValveDiscountPromotionsRequest) pack() []byte { +mut res := []byte{} +if o.has_country_code { +res << vproto.pack_string_field(o.country_code, 1) +} + +return res +} + +pub fn cuseraccountgetavailablevalvediscountpromotionsrequest_unpack(buf []byte) ?CUserAccountGetAvailableValveDiscountPromotionsRequest { +mut res := CUserAccountGetAvailableValveDiscountPromotionsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_country_code = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.country_code = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cuseraccountgetavailablevalvediscountpromotionsrequest() CUserAccountGetAvailableValveDiscountPromotionsRequest { +return CUserAccountGetAvailableValveDiscountPromotionsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cuseraccountgetavailablevalvediscountpromotionsrequest(o CUserAccountGetAvailableValveDiscountPromotionsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cuseraccountgetavailablevalvediscountpromotionsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CUserAccountGetAvailableValveDiscountPromotionsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cuseraccountgetavailablevalvediscountpromotionsrequest_unpack(v)? +return i, unpacked +} +pub struct CUserAccountGetAvailableValveDiscountPromotionsResponseValveDiscountPromotionDetails { +mut: +unknown_fields []vproto.UnknownField +pub mut: +promotionid u32 +has_promotionid bool +promotion_description string +has_promotion_description bool +minimum_cart_amount i64 +has_minimum_cart_amount bool +minimum_cart_amount_for_display i64 +has_minimum_cart_amount_for_display bool +discount_amount i64 +has_discount_amount bool +currency_code int +has_currency_code bool +available_use_count int +has_available_use_count bool +promotional_discount_type int +has_promotional_discount_type bool +loyalty_reward_id int +has_loyalty_reward_id bool +localized_name_token string +has_localized_name_token bool +max_use_count int +has_max_use_count bool +} +pub fn (o &CUserAccountGetAvailableValveDiscountPromotionsResponseValveDiscountPromotionDetails) pack() []byte { +mut res := []byte{} +if o.has_promotionid { +res << vproto.pack_uint32_field(o.promotionid, 1) +} + +if o.has_promotion_description { +res << vproto.pack_string_field(o.promotion_description, 2) +} + +if o.has_minimum_cart_amount { +res << vproto.pack_int64_field(o.minimum_cart_amount, 3) +} + +if o.has_minimum_cart_amount_for_display { +res << vproto.pack_int64_field(o.minimum_cart_amount_for_display, 4) +} + +if o.has_discount_amount { +res << vproto.pack_int64_field(o.discount_amount, 5) +} + +if o.has_currency_code { +res << vproto.pack_int32_field(o.currency_code, 6) +} + +if o.has_available_use_count { +res << vproto.pack_int32_field(o.available_use_count, 7) +} + +if o.has_promotional_discount_type { +res << vproto.pack_int32_field(o.promotional_discount_type, 8) +} + +if o.has_loyalty_reward_id { +res << vproto.pack_int32_field(o.loyalty_reward_id, 9) +} + +if o.has_localized_name_token { +res << vproto.pack_string_field(o.localized_name_token, 10) +} + +if o.has_max_use_count { +res << vproto.pack_int32_field(o.max_use_count, 11) +} + +return res +} + +pub fn cuseraccountgetavailablevalvediscountpromotionsresponsevalvediscountpromotiondetails_unpack(buf []byte) ?CUserAccountGetAvailableValveDiscountPromotionsResponseValveDiscountPromotionDetails { +mut res := CUserAccountGetAvailableValveDiscountPromotionsResponseValveDiscountPromotionDetails{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_promotionid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.promotionid = v +i = ii +} + +2 { +res.has_promotion_description = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.promotion_description = v +i = ii +} + +3 { +res.has_minimum_cart_amount = true +ii, v := vproto.unpack_int64_field(cur_buf, tag_wiretype.wire_type)? +res.minimum_cart_amount = v +i = ii +} + +4 { +res.has_minimum_cart_amount_for_display = true +ii, v := vproto.unpack_int64_field(cur_buf, tag_wiretype.wire_type)? +res.minimum_cart_amount_for_display = v +i = ii +} + +5 { +res.has_discount_amount = true +ii, v := vproto.unpack_int64_field(cur_buf, tag_wiretype.wire_type)? +res.discount_amount = v +i = ii +} + +6 { +res.has_currency_code = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.currency_code = v +i = ii +} + +7 { +res.has_available_use_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.available_use_count = v +i = ii +} + +8 { +res.has_promotional_discount_type = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.promotional_discount_type = v +i = ii +} + +9 { +res.has_loyalty_reward_id = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.loyalty_reward_id = v +i = ii +} + +10 { +res.has_localized_name_token = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.localized_name_token = v +i = ii +} + +11 { +res.has_max_use_count = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.max_use_count = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cuseraccountgetavailablevalvediscountpromotionsresponsevalvediscountpromotiondetails() CUserAccountGetAvailableValveDiscountPromotionsResponseValveDiscountPromotionDetails { +return CUserAccountGetAvailableValveDiscountPromotionsResponseValveDiscountPromotionDetails{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cuseraccountgetavailablevalvediscountpromotionsresponsevalvediscountpromotiondetails(o CUserAccountGetAvailableValveDiscountPromotionsResponseValveDiscountPromotionDetails, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cuseraccountgetavailablevalvediscountpromotionsresponsevalvediscountpromotiondetails(buf []byte, tag_wiretype vproto.WireType) ?(int, CUserAccountGetAvailableValveDiscountPromotionsResponseValveDiscountPromotionDetails) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cuseraccountgetavailablevalvediscountpromotionsresponsevalvediscountpromotiondetails_unpack(v)? +return i, unpacked +} +pub struct CUserAccountGetAvailableValveDiscountPromotionsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +promotions []CUserAccountGetAvailableValveDiscountPromotionsResponseValveDiscountPromotionDetails +} +pub fn (o &CUserAccountGetAvailableValveDiscountPromotionsResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.promotions { +res << zzz_vproto_internal_pack_cuseraccountgetavailablevalvediscountpromotionsresponsevalvediscountpromotiondetails(x, 1) +} + +return res +} + +pub fn cuseraccountgetavailablevalvediscountpromotionsresponse_unpack(buf []byte) ?CUserAccountGetAvailableValveDiscountPromotionsResponse { +mut res := CUserAccountGetAvailableValveDiscountPromotionsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cuseraccountgetavailablevalvediscountpromotionsresponsevalvediscountpromotiondetails(cur_buf, tag_wiretype.wire_type)? +res.promotions << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cuseraccountgetavailablevalvediscountpromotionsresponse() CUserAccountGetAvailableValveDiscountPromotionsResponse { +return CUserAccountGetAvailableValveDiscountPromotionsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cuseraccountgetavailablevalvediscountpromotionsresponse(o CUserAccountGetAvailableValveDiscountPromotionsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cuseraccountgetavailablevalvediscountpromotionsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CUserAccountGetAvailableValveDiscountPromotionsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cuseraccountgetavailablevalvediscountpromotionsresponse_unpack(v)? +return i, unpacked +} +pub struct CUserAccountGetAccountLinkStatusRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CUserAccountGetAccountLinkStatusRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn cuseraccountgetaccountlinkstatusrequest_unpack(buf []byte) ?CUserAccountGetAccountLinkStatusRequest { +res := CUserAccountGetAccountLinkStatusRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cuseraccountgetaccountlinkstatusrequest() CUserAccountGetAccountLinkStatusRequest { +return CUserAccountGetAccountLinkStatusRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cuseraccountgetaccountlinkstatusrequest(o CUserAccountGetAccountLinkStatusRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cuseraccountgetaccountlinkstatusrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CUserAccountGetAccountLinkStatusRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cuseraccountgetaccountlinkstatusrequest_unpack(v)? +return i, unpacked +} +pub struct CUserAccountGetAccountLinkStatusResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +pwid u32 +has_pwid bool +identity_verification u32 +has_identity_verification bool +performed_age_verification bool +has_performed_age_verification bool +} +pub fn (o &CUserAccountGetAccountLinkStatusResponse) pack() []byte { +mut res := []byte{} +if o.has_pwid { +res << vproto.pack_uint32_field(o.pwid, 1) +} + +if o.has_identity_verification { +res << vproto.pack_uint32_field(o.identity_verification, 2) +} + +if o.has_performed_age_verification { +res << vproto.pack_bool_field(o.performed_age_verification, 3) +} + +return res +} + +pub fn cuseraccountgetaccountlinkstatusresponse_unpack(buf []byte) ?CUserAccountGetAccountLinkStatusResponse { +mut res := CUserAccountGetAccountLinkStatusResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_pwid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.pwid = v +i = ii +} + +2 { +res.has_identity_verification = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.identity_verification = v +i = ii +} + +3 { +res.has_performed_age_verification = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.performed_age_verification = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cuseraccountgetaccountlinkstatusresponse() CUserAccountGetAccountLinkStatusResponse { +return CUserAccountGetAccountLinkStatusResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cuseraccountgetaccountlinkstatusresponse(o CUserAccountGetAccountLinkStatusResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cuseraccountgetaccountlinkstatusresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CUserAccountGetAccountLinkStatusResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cuseraccountgetaccountlinkstatusresponse_unpack(v)? +return i, unpacked +} +pub struct CUserAccountCancelLicenseForAppRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +} +pub fn (o &CUserAccountCancelLicenseForAppRequest) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +return res +} + +pub fn cuseraccountcancellicenseforapprequest_unpack(buf []byte) ?CUserAccountCancelLicenseForAppRequest { +mut res := CUserAccountCancelLicenseForAppRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cuseraccountcancellicenseforapprequest() CUserAccountCancelLicenseForAppRequest { +return CUserAccountCancelLicenseForAppRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cuseraccountcancellicenseforapprequest(o CUserAccountCancelLicenseForAppRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cuseraccountcancellicenseforapprequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CUserAccountCancelLicenseForAppRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cuseraccountcancellicenseforapprequest_unpack(v)? +return i, unpacked +} +pub struct CUserAccountCancelLicenseForAppResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CUserAccountCancelLicenseForAppResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cuseraccountcancellicenseforappresponse_unpack(buf []byte) ?CUserAccountCancelLicenseForAppResponse { +res := CUserAccountCancelLicenseForAppResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cuseraccountcancellicenseforappresponse() CUserAccountCancelLicenseForAppResponse { +return CUserAccountCancelLicenseForAppResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cuseraccountcancellicenseforappresponse(o CUserAccountCancelLicenseForAppResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cuseraccountcancellicenseforappresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CUserAccountCancelLicenseForAppResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cuseraccountcancellicenseforappresponse_unpack(v)? +return i, unpacked +} +pub struct CUserAccountCreateFriendInviteTokenRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +invite_limit u32 +has_invite_limit bool +invite_duration u32 +has_invite_duration bool +invite_note string +has_invite_note bool +} +pub fn (o &CUserAccountCreateFriendInviteTokenRequest) pack() []byte { +mut res := []byte{} +if o.has_invite_limit { +res << vproto.pack_uint32_field(o.invite_limit, 1) +} + +if o.has_invite_duration { +res << vproto.pack_uint32_field(o.invite_duration, 2) +} + +if o.has_invite_note { +res << vproto.pack_string_field(o.invite_note, 3) +} + +return res +} + +pub fn cuseraccountcreatefriendinvitetokenrequest_unpack(buf []byte) ?CUserAccountCreateFriendInviteTokenRequest { +mut res := CUserAccountCreateFriendInviteTokenRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_invite_limit = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.invite_limit = v +i = ii +} + +2 { +res.has_invite_duration = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.invite_duration = v +i = ii +} + +3 { +res.has_invite_note = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.invite_note = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cuseraccountcreatefriendinvitetokenrequest() CUserAccountCreateFriendInviteTokenRequest { +return CUserAccountCreateFriendInviteTokenRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cuseraccountcreatefriendinvitetokenrequest(o CUserAccountCreateFriendInviteTokenRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cuseraccountcreatefriendinvitetokenrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CUserAccountCreateFriendInviteTokenRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cuseraccountcreatefriendinvitetokenrequest_unpack(v)? +return i, unpacked +} +pub struct CUserAccountCreateFriendInviteTokenResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +invite_token string +has_invite_token bool +invite_limit u64 +has_invite_limit bool +invite_duration u64 +has_invite_duration bool +time_created u32 +has_time_created bool +valid bool +has_valid bool +} +pub fn (o &CUserAccountCreateFriendInviteTokenResponse) pack() []byte { +mut res := []byte{} +if o.has_invite_token { +res << vproto.pack_string_field(o.invite_token, 1) +} + +if o.has_invite_limit { +res << vproto.pack_uint64_field(o.invite_limit, 2) +} + +if o.has_invite_duration { +res << vproto.pack_uint64_field(o.invite_duration, 3) +} + +if o.has_time_created { +res << vproto.pack_32bit_field(o.time_created, 4) +} + +if o.has_valid { +res << vproto.pack_bool_field(o.valid, 5) +} + +return res +} + +pub fn cuseraccountcreatefriendinvitetokenresponse_unpack(buf []byte) ?CUserAccountCreateFriendInviteTokenResponse { +mut res := CUserAccountCreateFriendInviteTokenResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_invite_token = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.invite_token = v +i = ii +} + +2 { +res.has_invite_limit = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.invite_limit = v +i = ii +} + +3 { +res.has_invite_duration = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.invite_duration = v +i = ii +} + +4 { +res.has_time_created = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.time_created = v +i = ii +} + +5 { +res.has_valid = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.valid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cuseraccountcreatefriendinvitetokenresponse() CUserAccountCreateFriendInviteTokenResponse { +return CUserAccountCreateFriendInviteTokenResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cuseraccountcreatefriendinvitetokenresponse(o CUserAccountCreateFriendInviteTokenResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cuseraccountcreatefriendinvitetokenresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CUserAccountCreateFriendInviteTokenResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cuseraccountcreatefriendinvitetokenresponse_unpack(v)? +return i, unpacked +} +pub struct CUserAccountGetFriendInviteTokensRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CUserAccountGetFriendInviteTokensRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn cuseraccountgetfriendinvitetokensrequest_unpack(buf []byte) ?CUserAccountGetFriendInviteTokensRequest { +res := CUserAccountGetFriendInviteTokensRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cuseraccountgetfriendinvitetokensrequest() CUserAccountGetFriendInviteTokensRequest { +return CUserAccountGetFriendInviteTokensRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cuseraccountgetfriendinvitetokensrequest(o CUserAccountGetFriendInviteTokensRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cuseraccountgetfriendinvitetokensrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CUserAccountGetFriendInviteTokensRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cuseraccountgetfriendinvitetokensrequest_unpack(v)? +return i, unpacked +} +pub struct CUserAccountGetFriendInviteTokensResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +tokens []CUserAccountCreateFriendInviteTokenResponse +} +pub fn (o &CUserAccountGetFriendInviteTokensResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.tokens { +res << zzz_vproto_internal_pack_cuseraccountcreatefriendinvitetokenresponse(x, 1) +} + +return res +} + +pub fn cuseraccountgetfriendinvitetokensresponse_unpack(buf []byte) ?CUserAccountGetFriendInviteTokensResponse { +mut res := CUserAccountGetFriendInviteTokensResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cuseraccountcreatefriendinvitetokenresponse(cur_buf, tag_wiretype.wire_type)? +res.tokens << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cuseraccountgetfriendinvitetokensresponse() CUserAccountGetFriendInviteTokensResponse { +return CUserAccountGetFriendInviteTokensResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cuseraccountgetfriendinvitetokensresponse(o CUserAccountGetFriendInviteTokensResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cuseraccountgetfriendinvitetokensresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CUserAccountGetFriendInviteTokensResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cuseraccountgetfriendinvitetokensresponse_unpack(v)? +return i, unpacked +} +pub struct CUserAccountViewFriendInviteTokenRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +invite_token string +has_invite_token bool +} +pub fn (o &CUserAccountViewFriendInviteTokenRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_invite_token { +res << vproto.pack_string_field(o.invite_token, 2) +} + +return res +} + +pub fn cuseraccountviewfriendinvitetokenrequest_unpack(buf []byte) ?CUserAccountViewFriendInviteTokenRequest { +mut res := CUserAccountViewFriendInviteTokenRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_invite_token = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.invite_token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cuseraccountviewfriendinvitetokenrequest() CUserAccountViewFriendInviteTokenRequest { +return CUserAccountViewFriendInviteTokenRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cuseraccountviewfriendinvitetokenrequest(o CUserAccountViewFriendInviteTokenRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cuseraccountviewfriendinvitetokenrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CUserAccountViewFriendInviteTokenRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cuseraccountviewfriendinvitetokenrequest_unpack(v)? +return i, unpacked +} +pub struct CUserAccountViewFriendInviteTokenResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +valid bool +has_valid bool +steamid u64 +has_steamid bool +invite_duration u64 +has_invite_duration bool +} +pub fn (o &CUserAccountViewFriendInviteTokenResponse) pack() []byte { +mut res := []byte{} +if o.has_valid { +res << vproto.pack_bool_field(o.valid, 1) +} + +if o.has_steamid { +res << vproto.pack_uint64_field(o.steamid, 2) +} + +if o.has_invite_duration { +res << vproto.pack_uint64_field(o.invite_duration, 3) +} + +return res +} + +pub fn cuseraccountviewfriendinvitetokenresponse_unpack(buf []byte) ?CUserAccountViewFriendInviteTokenResponse { +mut res := CUserAccountViewFriendInviteTokenResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_valid = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.valid = v +i = ii +} + +2 { +res.has_steamid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +3 { +res.has_invite_duration = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.invite_duration = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cuseraccountviewfriendinvitetokenresponse() CUserAccountViewFriendInviteTokenResponse { +return CUserAccountViewFriendInviteTokenResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cuseraccountviewfriendinvitetokenresponse(o CUserAccountViewFriendInviteTokenResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cuseraccountviewfriendinvitetokenresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CUserAccountViewFriendInviteTokenResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cuseraccountviewfriendinvitetokenresponse_unpack(v)? +return i, unpacked +} +pub struct CUserAccountRedeemFriendInviteTokenRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +invite_token string +has_invite_token bool +} +pub fn (o &CUserAccountRedeemFriendInviteTokenRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_invite_token { +res << vproto.pack_string_field(o.invite_token, 2) +} + +return res +} + +pub fn cuseraccountredeemfriendinvitetokenrequest_unpack(buf []byte) ?CUserAccountRedeemFriendInviteTokenRequest { +mut res := CUserAccountRedeemFriendInviteTokenRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_invite_token = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.invite_token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cuseraccountredeemfriendinvitetokenrequest() CUserAccountRedeemFriendInviteTokenRequest { +return CUserAccountRedeemFriendInviteTokenRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cuseraccountredeemfriendinvitetokenrequest(o CUserAccountRedeemFriendInviteTokenRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cuseraccountredeemfriendinvitetokenrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CUserAccountRedeemFriendInviteTokenRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cuseraccountredeemfriendinvitetokenrequest_unpack(v)? +return i, unpacked +} +pub struct CUserAccountRedeemFriendInviteTokenResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CUserAccountRedeemFriendInviteTokenResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cuseraccountredeemfriendinvitetokenresponse_unpack(buf []byte) ?CUserAccountRedeemFriendInviteTokenResponse { +res := CUserAccountRedeemFriendInviteTokenResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cuseraccountredeemfriendinvitetokenresponse() CUserAccountRedeemFriendInviteTokenResponse { +return CUserAccountRedeemFriendInviteTokenResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cuseraccountredeemfriendinvitetokenresponse(o CUserAccountRedeemFriendInviteTokenResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cuseraccountredeemfriendinvitetokenresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CUserAccountRedeemFriendInviteTokenResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cuseraccountredeemfriendinvitetokenresponse_unpack(v)? +return i, unpacked +} +pub struct CUserAccountRevokeFriendInviteTokenRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +invite_token string +has_invite_token bool +} +pub fn (o &CUserAccountRevokeFriendInviteTokenRequest) pack() []byte { +mut res := []byte{} +if o.has_invite_token { +res << vproto.pack_string_field(o.invite_token, 1) +} + +return res +} + +pub fn cuseraccountrevokefriendinvitetokenrequest_unpack(buf []byte) ?CUserAccountRevokeFriendInviteTokenRequest { +mut res := CUserAccountRevokeFriendInviteTokenRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_invite_token = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.invite_token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cuseraccountrevokefriendinvitetokenrequest() CUserAccountRevokeFriendInviteTokenRequest { +return CUserAccountRevokeFriendInviteTokenRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cuseraccountrevokefriendinvitetokenrequest(o CUserAccountRevokeFriendInviteTokenRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cuseraccountrevokefriendinvitetokenrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CUserAccountRevokeFriendInviteTokenRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cuseraccountrevokefriendinvitetokenrequest_unpack(v)? +return i, unpacked +} +pub struct CUserAccountRevokeFriendInviteTokenResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CUserAccountRevokeFriendInviteTokenResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cuseraccountrevokefriendinvitetokenresponse_unpack(buf []byte) ?CUserAccountRevokeFriendInviteTokenResponse { +res := CUserAccountRevokeFriendInviteTokenResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cuseraccountrevokefriendinvitetokenresponse() CUserAccountRevokeFriendInviteTokenResponse { +return CUserAccountRevokeFriendInviteTokenResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cuseraccountrevokefriendinvitetokenresponse(o CUserAccountRevokeFriendInviteTokenResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cuseraccountrevokefriendinvitetokenresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CUserAccountRevokeFriendInviteTokenResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cuseraccountrevokefriendinvitetokenresponse_unpack(v)? +return i, unpacked +} +pub struct CUserAccountRegisterCompatToolRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +compat_tool u32 +has_compat_tool bool +} +pub fn (o &CUserAccountRegisterCompatToolRequest) pack() []byte { +mut res := []byte{} +if o.has_compat_tool { +res << vproto.pack_uint32_field(o.compat_tool, 1) +} + +return res +} + +pub fn cuseraccountregistercompattoolrequest_unpack(buf []byte) ?CUserAccountRegisterCompatToolRequest { +mut res := CUserAccountRegisterCompatToolRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_compat_tool = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.compat_tool = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cuseraccountregistercompattoolrequest() CUserAccountRegisterCompatToolRequest { +return CUserAccountRegisterCompatToolRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cuseraccountregistercompattoolrequest(o CUserAccountRegisterCompatToolRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cuseraccountregistercompattoolrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CUserAccountRegisterCompatToolRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cuseraccountregistercompattoolrequest_unpack(v)? +return i, unpacked +} +pub struct CUserAccountRegisterCompatToolResponse { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CUserAccountRegisterCompatToolResponse) pack() []byte { +res := []byte{} +return res +} + +pub fn cuseraccountregistercompattoolresponse_unpack(buf []byte) ?CUserAccountRegisterCompatToolResponse { +res := CUserAccountRegisterCompatToolResponse{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cuseraccountregistercompattoolresponse() CUserAccountRegisterCompatToolResponse { +return CUserAccountRegisterCompatToolResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cuseraccountregistercompattoolresponse(o CUserAccountRegisterCompatToolResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cuseraccountregistercompattoolresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CUserAccountRegisterCompatToolResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cuseraccountregistercompattoolresponse_unpack(v)? +return i, unpacked +} +pub struct CAccountLinkingGetLinkedAccountInfoRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +account_type EInternalAccountType +has_account_type bool +account_id u64 +has_account_id bool +filter EExternalAccountType +has_filter bool +return_access_token bool +has_return_access_token bool +} +pub fn (o &CAccountLinkingGetLinkedAccountInfoRequest) pack() []byte { +mut res := []byte{} +if o.has_account_type { +res << zzz_vproto_internal_pack_einternalaccounttype(o.account_type, 1) +} + +if o.has_account_id { +res << vproto.pack_uint64_field(o.account_id, 2) +} + +if o.has_filter { +res << zzz_vproto_internal_pack_eexternalaccounttype(o.filter, 3) +} + +if o.has_return_access_token { +res << vproto.pack_bool_field(o.return_access_token, 4) +} + +return res +} + +pub fn caccountlinkinggetlinkedaccountinforequest_unpack(buf []byte) ?CAccountLinkingGetLinkedAccountInfoRequest { +mut res := CAccountLinkingGetLinkedAccountInfoRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_account_type = true +ii, v := zzz_vproto_internal_unpack_einternalaccounttype(cur_buf, tag_wiretype.wire_type)? +res.account_type = v +i = ii +} + +2 { +res.has_account_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.account_id = v +i = ii +} + +3 { +res.has_filter = true +ii, v := zzz_vproto_internal_unpack_eexternalaccounttype(cur_buf, tag_wiretype.wire_type)? +res.filter = v +i = ii +} + +4 { +res.has_return_access_token = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.return_access_token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccountlinkinggetlinkedaccountinforequest() CAccountLinkingGetLinkedAccountInfoRequest { +return CAccountLinkingGetLinkedAccountInfoRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccountlinkinggetlinkedaccountinforequest(o CAccountLinkingGetLinkedAccountInfoRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccountlinkinggetlinkedaccountinforequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountLinkingGetLinkedAccountInfoRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccountlinkinggetlinkedaccountinforequest_unpack(v)? +return i, unpacked +} +pub struct CAccountLinkingGetLinkedAccountInfoResponseCExternalAccountTupleResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +external_type EExternalAccountType +has_external_type bool +external_id string +has_external_id bool +external_user_name string +has_external_user_name bool +external_url string +has_external_url bool +access_token string +has_access_token bool +access_token_secret string +has_access_token_secret bool +is_valid bool +has_is_valid bool +} +pub fn (o &CAccountLinkingGetLinkedAccountInfoResponseCExternalAccountTupleResponse) pack() []byte { +mut res := []byte{} +if o.has_external_type { +res << zzz_vproto_internal_pack_eexternalaccounttype(o.external_type, 1) +} + +if o.has_external_id { +res << vproto.pack_string_field(o.external_id, 2) +} + +if o.has_external_user_name { +res << vproto.pack_string_field(o.external_user_name, 3) +} + +if o.has_external_url { +res << vproto.pack_string_field(o.external_url, 4) +} + +if o.has_access_token { +res << vproto.pack_string_field(o.access_token, 5) +} + +if o.has_access_token_secret { +res << vproto.pack_string_field(o.access_token_secret, 6) +} + +if o.has_is_valid { +res << vproto.pack_bool_field(o.is_valid, 7) +} + +return res +} + +pub fn caccountlinkinggetlinkedaccountinforesponsecexternalaccounttupleresponse_unpack(buf []byte) ?CAccountLinkingGetLinkedAccountInfoResponseCExternalAccountTupleResponse { +mut res := CAccountLinkingGetLinkedAccountInfoResponseCExternalAccountTupleResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_external_type = true +ii, v := zzz_vproto_internal_unpack_eexternalaccounttype(cur_buf, tag_wiretype.wire_type)? +res.external_type = v +i = ii +} + +2 { +res.has_external_id = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.external_id = v +i = ii +} + +3 { +res.has_external_user_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.external_user_name = v +i = ii +} + +4 { +res.has_external_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.external_url = v +i = ii +} + +5 { +res.has_access_token = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.access_token = v +i = ii +} + +6 { +res.has_access_token_secret = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.access_token_secret = v +i = ii +} + +7 { +res.has_is_valid = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.is_valid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccountlinkinggetlinkedaccountinforesponsecexternalaccounttupleresponse() CAccountLinkingGetLinkedAccountInfoResponseCExternalAccountTupleResponse { +return CAccountLinkingGetLinkedAccountInfoResponseCExternalAccountTupleResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccountlinkinggetlinkedaccountinforesponsecexternalaccounttupleresponse(o CAccountLinkingGetLinkedAccountInfoResponseCExternalAccountTupleResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccountlinkinggetlinkedaccountinforesponsecexternalaccounttupleresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountLinkingGetLinkedAccountInfoResponseCExternalAccountTupleResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccountlinkinggetlinkedaccountinforesponsecexternalaccounttupleresponse_unpack(v)? +return i, unpacked +} +pub struct CAccountLinkingGetLinkedAccountInfoResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +external_accounts []CAccountLinkingGetLinkedAccountInfoResponseCExternalAccountTupleResponse +} +pub fn (o &CAccountLinkingGetLinkedAccountInfoResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.external_accounts { +res << zzz_vproto_internal_pack_caccountlinkinggetlinkedaccountinforesponsecexternalaccounttupleresponse(x, 1) +} + +return res +} + +pub fn caccountlinkinggetlinkedaccountinforesponse_unpack(buf []byte) ?CAccountLinkingGetLinkedAccountInfoResponse { +mut res := CAccountLinkingGetLinkedAccountInfoResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_caccountlinkinggetlinkedaccountinforesponsecexternalaccounttupleresponse(cur_buf, tag_wiretype.wire_type)? +res.external_accounts << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caccountlinkinggetlinkedaccountinforesponse() CAccountLinkingGetLinkedAccountInfoResponse { +return CAccountLinkingGetLinkedAccountInfoResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caccountlinkinggetlinkedaccountinforesponse(o CAccountLinkingGetLinkedAccountInfoResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caccountlinkinggetlinkedaccountinforesponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CAccountLinkingGetLinkedAccountInfoResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caccountlinkinggetlinkedaccountinforesponse_unpack(v)? +return i, unpacked +} +pub struct CEmbeddedClientAuthorizeCurrentDeviceRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +appid u32 +has_appid bool +device_info string +has_device_info bool +deviceid u32 +has_deviceid bool +} +pub fn (o &CEmbeddedClientAuthorizeCurrentDeviceRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 2) +} + +if o.has_device_info { +res << vproto.pack_string_field(o.device_info, 3) +} + +if o.has_deviceid { +res << vproto.pack_uint32_field(o.deviceid, 4) +} + +return res +} + +pub fn cembeddedclientauthorizecurrentdevicerequest_unpack(buf []byte) ?CEmbeddedClientAuthorizeCurrentDeviceRequest { +mut res := CEmbeddedClientAuthorizeCurrentDeviceRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +3 { +res.has_device_info = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.device_info = v +i = ii +} + +4 { +res.has_deviceid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.deviceid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cembeddedclientauthorizecurrentdevicerequest() CEmbeddedClientAuthorizeCurrentDeviceRequest { +return CEmbeddedClientAuthorizeCurrentDeviceRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cembeddedclientauthorizecurrentdevicerequest(o CEmbeddedClientAuthorizeCurrentDeviceRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cembeddedclientauthorizecurrentdevicerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CEmbeddedClientAuthorizeCurrentDeviceRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cembeddedclientauthorizecurrentdevicerequest_unpack(v)? +return i, unpacked +} +pub struct CEmbeddedClientToken { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +client_token []byte +has_client_token bool +expiry u32 +has_expiry bool +deviceid u32 +has_deviceid bool +} +pub fn (o &CEmbeddedClientToken) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_client_token { +res << vproto.pack_bytes_field(o.client_token, 2) +} + +if o.has_expiry { +res << vproto.pack_uint32_field(o.expiry, 3) +} + +if o.has_deviceid { +res << vproto.pack_uint32_field(o.deviceid, 4) +} + +return res +} + +pub fn cembeddedclienttoken_unpack(buf []byte) ?CEmbeddedClientToken { +mut res := CEmbeddedClientToken{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_client_token = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.client_token = v +i = ii +} + +3 { +res.has_expiry = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.expiry = v +i = ii +} + +4 { +res.has_deviceid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.deviceid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cembeddedclienttoken() CEmbeddedClientToken { +return CEmbeddedClientToken{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cembeddedclienttoken(o CEmbeddedClientToken, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cembeddedclienttoken(buf []byte, tag_wiretype vproto.WireType) ?(int, CEmbeddedClientToken) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cembeddedclienttoken_unpack(v)? +return i, unpacked +} +pub struct CEmbeddedClientAuthorizeDeviceResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +result u32 +has_result bool +token CEmbeddedClientToken +has_token bool +} +pub fn (o &CEmbeddedClientAuthorizeDeviceResponse) pack() []byte { +mut res := []byte{} +if o.has_result { +res << vproto.pack_uint32_field(o.result, 1) +} + +if o.has_token { +res << zzz_vproto_internal_pack_cembeddedclienttoken(o.token, 2) +} + +return res +} + +pub fn cembeddedclientauthorizedeviceresponse_unpack(buf []byte) ?CEmbeddedClientAuthorizeDeviceResponse { +mut res := CEmbeddedClientAuthorizeDeviceResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_result = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.result = v +i = ii +} + +2 { +res.has_token = true +ii, v := zzz_vproto_internal_unpack_cembeddedclienttoken(cur_buf, tag_wiretype.wire_type)? +res.token = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cembeddedclientauthorizedeviceresponse() CEmbeddedClientAuthorizeDeviceResponse { +return CEmbeddedClientAuthorizeDeviceResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cembeddedclientauthorizedeviceresponse(o CEmbeddedClientAuthorizeDeviceResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cembeddedclientauthorizedeviceresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CEmbeddedClientAuthorizeDeviceResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cembeddedclientauthorizedeviceresponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_vac.steamclient_pb.v b/proto/steammessages_vac.steamclient_pb.v new file mode 100644 index 0000000..da2ff62 --- /dev/null +++ b/proto/steammessages_vac.steamclient_pb.v @@ -0,0 +1,395 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CFileVerificationSignatureCheckRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steamid u64 +has_steamid bool +appid u32 +has_appid bool +file_size u64 +has_file_size bool +file_timestamp u32 +has_file_timestamp bool +file_timestamp2 u32 +has_file_timestamp2 bool +signature_result u32 +has_signature_result bool +filename string +has_filename bool +client_package_version u32 +has_client_package_version bool +sha1hash []byte +has_sha1hash bool +} +pub fn (o &CFileVerificationSignatureCheckRequest) pack() []byte { +mut res := []byte{} +if o.has_steamid { +res << vproto.pack_64bit_field(o.steamid, 1) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 2) +} + +if o.has_file_size { +res << vproto.pack_uint64_field(o.file_size, 3) +} + +if o.has_file_timestamp { +res << vproto.pack_uint32_field(o.file_timestamp, 4) +} + +if o.has_file_timestamp2 { +res << vproto.pack_uint32_field(o.file_timestamp2, 5) +} + +if o.has_signature_result { +res << vproto.pack_uint32_field(o.signature_result, 6) +} + +if o.has_filename { +res << vproto.pack_string_field(o.filename, 7) +} + +if o.has_client_package_version { +res << vproto.pack_uint32_field(o.client_package_version, 8) +} + +if o.has_sha1hash { +res << vproto.pack_bytes_field(o.sha1hash, 9) +} + +return res +} + +pub fn cfileverificationsignaturecheckrequest_unpack(buf []byte) ?CFileVerificationSignatureCheckRequest { +mut res := CFileVerificationSignatureCheckRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_steamid = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steamid = v +i = ii +} + +2 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +3 { +res.has_file_size = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.file_size = v +i = ii +} + +4 { +res.has_file_timestamp = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.file_timestamp = v +i = ii +} + +5 { +res.has_file_timestamp2 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.file_timestamp2 = v +i = ii +} + +6 { +res.has_signature_result = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.signature_result = v +i = ii +} + +7 { +res.has_filename = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.filename = v +i = ii +} + +8 { +res.has_client_package_version = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.client_package_version = v +i = ii +} + +9 { +res.has_sha1hash = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sha1hash = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cfileverificationsignaturecheckrequest() CFileVerificationSignatureCheckRequest { +return CFileVerificationSignatureCheckRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cfileverificationsignaturecheckrequest(o CFileVerificationSignatureCheckRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cfileverificationsignaturecheckrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CFileVerificationSignatureCheckRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cfileverificationsignaturecheckrequest_unpack(v)? +return i, unpacked +} +pub struct CFileVerificationSignatureCheckResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +deny_operation bool +has_deny_operation bool +} +pub fn (o &CFileVerificationSignatureCheckResponse) pack() []byte { +mut res := []byte{} +if o.has_deny_operation { +res << vproto.pack_bool_field(o.deny_operation, 1) +} + +return res +} + +pub fn cfileverificationsignaturecheckresponse_unpack(buf []byte) ?CFileVerificationSignatureCheckResponse { +mut res := CFileVerificationSignatureCheckResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_deny_operation = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.deny_operation = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cfileverificationsignaturecheckresponse() CFileVerificationSignatureCheckResponse { +return CFileVerificationSignatureCheckResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cfileverificationsignaturecheckresponse(o CFileVerificationSignatureCheckResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cfileverificationsignaturecheckresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CFileVerificationSignatureCheckResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cfileverificationsignaturecheckresponse_unpack(v)? +return i, unpacked +} +pub struct CFileVerificationSteamServiceCheckRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +service_status u32 +has_service_status bool +client_package_version u32 +has_client_package_version bool +launcher_type u32 +has_launcher_type bool +os_type u32 +has_os_type bool +service_repair u32 +has_service_repair bool +} +pub fn (o &CFileVerificationSteamServiceCheckRequest) pack() []byte { +mut res := []byte{} +if o.has_service_status { +res << vproto.pack_uint32_field(o.service_status, 2) +} + +if o.has_client_package_version { +res << vproto.pack_uint32_field(o.client_package_version, 3) +} + +if o.has_launcher_type { +res << vproto.pack_uint32_field(o.launcher_type, 4) +} + +if o.has_os_type { +res << vproto.pack_uint32_field(o.os_type, 5) +} + +if o.has_service_repair { +res << vproto.pack_uint32_field(o.service_repair, 6) +} + +return res +} + +pub fn cfileverificationsteamservicecheckrequest_unpack(buf []byte) ?CFileVerificationSteamServiceCheckRequest { +mut res := CFileVerificationSteamServiceCheckRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +2 { +res.has_service_status = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.service_status = v +i = ii +} + +3 { +res.has_client_package_version = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.client_package_version = v +i = ii +} + +4 { +res.has_launcher_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.launcher_type = v +i = ii +} + +5 { +res.has_os_type = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.os_type = v +i = ii +} + +6 { +res.has_service_repair = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.service_repair = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cfileverificationsteamservicecheckrequest() CFileVerificationSteamServiceCheckRequest { +return CFileVerificationSteamServiceCheckRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cfileverificationsteamservicecheckrequest(o CFileVerificationSteamServiceCheckRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cfileverificationsteamservicecheckrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CFileVerificationSteamServiceCheckRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cfileverificationsteamservicecheckrequest_unpack(v)? +return i, unpacked +} +pub struct CFileVerificationSteamServiceCheckResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +attempt_repair bool +has_attempt_repair bool +} +pub fn (o &CFileVerificationSteamServiceCheckResponse) pack() []byte { +mut res := []byte{} +if o.has_attempt_repair { +res << vproto.pack_bool_field(o.attempt_repair, 1) +} + +return res +} + +pub fn cfileverificationsteamservicecheckresponse_unpack(buf []byte) ?CFileVerificationSteamServiceCheckResponse { +mut res := CFileVerificationSteamServiceCheckResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_attempt_repair = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.attempt_repair = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cfileverificationsteamservicecheckresponse() CFileVerificationSteamServiceCheckResponse { +return CFileVerificationSteamServiceCheckResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cfileverificationsteamservicecheckresponse(o CFileVerificationSteamServiceCheckResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cfileverificationsteamservicecheckresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CFileVerificationSteamServiceCheckResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cfileverificationsteamservicecheckresponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_video.steamclient_pb.v b/proto/steammessages_video.steamclient_pb.v new file mode 100644 index 0000000..ffa3c8c --- /dev/null +++ b/proto/steammessages_video.steamclient_pb.v @@ -0,0 +1,685 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CVideoClientGetVideoURlrequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +video_id u64 +has_video_id bool +client_cellid u32 +has_client_cellid bool +} +pub fn (o &CVideoClientGetVideoURlrequest) pack() []byte { +mut res := []byte{} +if o.has_video_id { +res << vproto.pack_uint64_field(o.video_id, 1) +} + +if o.has_client_cellid { +res << vproto.pack_uint32_field(o.client_cellid, 2) +} + +return res +} + +pub fn cvideoclientgetvideourlrequest_unpack(buf []byte) ?CVideoClientGetVideoURlrequest { +mut res := CVideoClientGetVideoURlrequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_video_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.video_id = v +i = ii +} + +2 { +res.has_client_cellid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.client_cellid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cvideoclientgetvideourlrequest() CVideoClientGetVideoURlrequest { +return CVideoClientGetVideoURlrequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cvideoclientgetvideourlrequest(o CVideoClientGetVideoURlrequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cvideoclientgetvideourlrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CVideoClientGetVideoURlrequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cvideoclientgetvideourlrequest_unpack(v)? +return i, unpacked +} +pub struct CVideoClientGetVideoURlresponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +video_id u64 +has_video_id bool +video_url string +has_video_url bool +} +pub fn (o &CVideoClientGetVideoURlresponse) pack() []byte { +mut res := []byte{} +if o.has_video_id { +res << vproto.pack_uint64_field(o.video_id, 1) +} + +if o.has_video_url { +res << vproto.pack_string_field(o.video_url, 2) +} + +return res +} + +pub fn cvideoclientgetvideourlresponse_unpack(buf []byte) ?CVideoClientGetVideoURlresponse { +mut res := CVideoClientGetVideoURlresponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_video_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.video_id = v +i = ii +} + +2 { +res.has_video_url = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.video_url = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cvideoclientgetvideourlresponse() CVideoClientGetVideoURlresponse { +return CVideoClientGetVideoURlresponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cvideoclientgetvideourlresponse(o CVideoClientGetVideoURlresponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cvideoclientgetvideourlresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CVideoClientGetVideoURlresponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cvideoclientgetvideourlresponse_unpack(v)? +return i, unpacked +} +pub struct VideoBookmark { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +playback_position_in_seconds u32 +has_playback_position_in_seconds bool +video_track_id u64 +has_video_track_id bool +audio_track_id u64 +has_audio_track_id bool +timedtext_track_id u64 +has_timedtext_track_id bool +last_modified u32 +has_last_modified bool +hide_from_watch_history bool +has_hide_from_watch_history bool +hide_from_library bool +has_hide_from_library bool +} +pub fn (o &VideoBookmark) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_playback_position_in_seconds { +res << vproto.pack_uint32_field(o.playback_position_in_seconds, 2) +} + +if o.has_video_track_id { +res << vproto.pack_uint64_field(o.video_track_id, 3) +} + +if o.has_audio_track_id { +res << vproto.pack_uint64_field(o.audio_track_id, 4) +} + +if o.has_timedtext_track_id { +res << vproto.pack_uint64_field(o.timedtext_track_id, 5) +} + +if o.has_last_modified { +res << vproto.pack_uint32_field(o.last_modified, 6) +} + +if o.has_hide_from_watch_history { +res << vproto.pack_bool_field(o.hide_from_watch_history, 7) +} + +if o.has_hide_from_library { +res << vproto.pack_bool_field(o.hide_from_library, 8) +} + +return res +} + +pub fn videobookmark_unpack(buf []byte) ?VideoBookmark { +mut res := VideoBookmark{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_playback_position_in_seconds = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.playback_position_in_seconds = v +i = ii +} + +3 { +res.has_video_track_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.video_track_id = v +i = ii +} + +4 { +res.has_audio_track_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.audio_track_id = v +i = ii +} + +5 { +res.has_timedtext_track_id = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.timedtext_track_id = v +i = ii +} + +6 { +res.has_last_modified = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.last_modified = v +i = ii +} + +7 { +res.has_hide_from_watch_history = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.hide_from_watch_history = v +i = ii +} + +8 { +res.has_hide_from_library = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.hide_from_library = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_videobookmark() VideoBookmark { +return VideoBookmark{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_videobookmark(o VideoBookmark, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_videobookmark(buf []byte, tag_wiretype vproto.WireType) ?(int, VideoBookmark) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := videobookmark_unpack(v)? +return i, unpacked +} +pub struct CVideoSetVideoBookmarkNotification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +bookmarks []VideoBookmark +} +pub fn (o &CVideoSetVideoBookmarkNotification) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.bookmarks { +res << zzz_vproto_internal_pack_videobookmark(x, 1) +} + +return res +} + +pub fn cvideosetvideobookmarknotification_unpack(buf []byte) ?CVideoSetVideoBookmarkNotification { +mut res := CVideoSetVideoBookmarkNotification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_videobookmark(cur_buf, tag_wiretype.wire_type)? +res.bookmarks << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cvideosetvideobookmarknotification() CVideoSetVideoBookmarkNotification { +return CVideoSetVideoBookmarkNotification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cvideosetvideobookmarknotification(o CVideoSetVideoBookmarkNotification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cvideosetvideobookmarknotification(buf []byte, tag_wiretype vproto.WireType) ?(int, CVideoSetVideoBookmarkNotification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cvideosetvideobookmarknotification_unpack(v)? +return i, unpacked +} +pub struct CVideoGetVideoBookmarksRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appids []u32 +updated_since u32 +has_updated_since bool +} +pub fn (o &CVideoGetVideoBookmarksRequest) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.appids { +res << vproto.pack_uint32_field(x, 1) +} + +if o.has_updated_since { +res << vproto.pack_uint32_field(o.updated_since, 2) +} + +return res +} + +pub fn cvideogetvideobookmarksrequest_unpack(buf []byte) ?CVideoGetVideoBookmarksRequest { +mut res := CVideoGetVideoBookmarksRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appids << v +i = ii +} + +2 { +res.has_updated_since = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.updated_since = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cvideogetvideobookmarksrequest() CVideoGetVideoBookmarksRequest { +return CVideoGetVideoBookmarksRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cvideogetvideobookmarksrequest(o CVideoGetVideoBookmarksRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cvideogetvideobookmarksrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CVideoGetVideoBookmarksRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cvideogetvideobookmarksrequest_unpack(v)? +return i, unpacked +} +pub struct CVideoGetVideoBookmarksResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +bookmarks []VideoBookmark +} +pub fn (o &CVideoGetVideoBookmarksResponse) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.bookmarks { +res << zzz_vproto_internal_pack_videobookmark(x, 1) +} + +return res +} + +pub fn cvideogetvideobookmarksresponse_unpack(buf []byte) ?CVideoGetVideoBookmarksResponse { +mut res := CVideoGetVideoBookmarksResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_videobookmark(cur_buf, tag_wiretype.wire_type)? +res.bookmarks << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cvideogetvideobookmarksresponse() CVideoGetVideoBookmarksResponse { +return CVideoGetVideoBookmarksResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cvideogetvideobookmarksresponse(o CVideoGetVideoBookmarksResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cvideogetvideobookmarksresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CVideoGetVideoBookmarksResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cvideogetvideobookmarksresponse_unpack(v)? +return i, unpacked +} +pub struct CVideoUnlockedH264Notification { +mut: +unknown_fields []vproto.UnknownField +pub mut: +encryption_key []byte +has_encryption_key bool +} +pub fn (o &CVideoUnlockedH264Notification) pack() []byte { +mut res := []byte{} +if o.has_encryption_key { +res << vproto.pack_bytes_field(o.encryption_key, 1) +} + +return res +} + +pub fn cvideounlockedh264notification_unpack(buf []byte) ?CVideoUnlockedH264Notification { +mut res := CVideoUnlockedH264Notification{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_encryption_key = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.encryption_key = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cvideounlockedh264notification() CVideoUnlockedH264Notification { +return CVideoUnlockedH264Notification{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cvideounlockedh264notification(o CVideoUnlockedH264Notification, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cvideounlockedh264notification(buf []byte, tag_wiretype vproto.WireType) ?(int, CVideoUnlockedH264Notification) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cvideounlockedh264notification_unpack(v)? +return i, unpacked +} +pub struct CFovasVideoClientGetOPfsettingsRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +client_cellid u32 +has_client_cellid bool +} +pub fn (o &CFovasVideoClientGetOPfsettingsRequest) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_client_cellid { +res << vproto.pack_uint32_field(o.client_cellid, 2) +} + +return res +} + +pub fn cfovasvideoclientgetopfsettingsrequest_unpack(buf []byte) ?CFovasVideoClientGetOPfsettingsRequest { +mut res := CFovasVideoClientGetOPfsettingsRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_client_cellid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.client_cellid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cfovasvideoclientgetopfsettingsrequest() CFovasVideoClientGetOPfsettingsRequest { +return CFovasVideoClientGetOPfsettingsRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cfovasvideoclientgetopfsettingsrequest(o CFovasVideoClientGetOPfsettingsRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cfovasvideoclientgetopfsettingsrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CFovasVideoClientGetOPfsettingsRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cfovasvideoclientgetopfsettingsrequest_unpack(v)? +return i, unpacked +} +pub struct CFovasVideoClientGetOPfsettingsResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +app_id u32 +has_app_id bool +opf_settings string +has_opf_settings bool +} +pub fn (o &CFovasVideoClientGetOPfsettingsResponse) pack() []byte { +mut res := []byte{} +if o.has_app_id { +res << vproto.pack_uint32_field(o.app_id, 1) +} + +if o.has_opf_settings { +res << vproto.pack_string_field(o.opf_settings, 2) +} + +return res +} + +pub fn cfovasvideoclientgetopfsettingsresponse_unpack(buf []byte) ?CFovasVideoClientGetOPfsettingsResponse { +mut res := CFovasVideoClientGetOPfsettingsResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_app_id = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_id = v +i = ii +} + +2 { +res.has_opf_settings = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.opf_settings = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cfovasvideoclientgetopfsettingsresponse() CFovasVideoClientGetOPfsettingsResponse { +return CFovasVideoClientGetOPfsettingsResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cfovasvideoclientgetopfsettingsresponse(o CFovasVideoClientGetOPfsettingsResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cfovasvideoclientgetopfsettingsresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CFovasVideoClientGetOPfsettingsResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cfovasvideoclientgetopfsettingsresponse_unpack(v)? +return i, unpacked +} diff --git a/proto/steammessages_virtualcontroller_pb.v b/proto/steammessages_virtualcontroller_pb.v new file mode 100644 index 0000000..fc838b6 --- /dev/null +++ b/proto/steammessages_virtualcontroller_pb.v @@ -0,0 +1,1235 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +[_allow_multiple_values] +enum EInputMode { +k_einputmodeunknown = 0 +k_einputmodemouse = 1 +k_einputmodecontroller = 2 +k_einputmodemouseandcontroller = 3 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_einputmode(e EInputMode, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_einputmode(buf []byte, tag_wiretype vproto.WireType) ?(int, EInputMode) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EInputMode(v) +} +[_allow_multiple_values] +enum EMouseMode { +k_emousemodeunknown = 0 +k_emousemoderelativecursor = 1 +k_emousemodeabsolutecursor = 2 +k_emousemodetouch = 3 +k_emousemoderelative = 4 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_emousemode(e EMouseMode, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_emousemode(buf []byte, tag_wiretype vproto.WireType) ?(int, EMouseMode) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EMouseMode(v) +} +[_allow_multiple_values] +enum EControllerElementType { +k_econtrollerelementtypenone = -1 +k_econtrollerelementtypethumb = 0 +k_econtrollerelementtypebuttonsteam = 1 +k_econtrollerelementtypejoystickleft = 2 +k_econtrollerelementtypebuttonjoystickleft = 3 +k_econtrollerelementtypejoystickright = 4 +k_econtrollerelementtypebuttonjoystickright = 5 +k_econtrollerelementtypedpad = 6 +k_econtrollerelementtypebuttona = 7 +k_econtrollerelementtypebuttonb = 8 +k_econtrollerelementtypebuttonx = 9 +k_econtrollerelementtypebuttony = 10 +k_econtrollerelementtypebuttonselect = 11 +k_econtrollerelementtypebuttonstart = 12 +k_econtrollerelementtypebuttontriggerleft = 13 +k_econtrollerelementtypebuttontriggerright = 14 +k_econtrollerelementtypebuttonbumperleft = 15 +k_econtrollerelementtypebuttonbumperright = 16 +k_econtrollerelementtypebuttonmacro0 = 17 +k_econtrollerelementtypebuttonmacro1 = 18 +k_econtrollerelementtypebuttonmacro2 = 19 +k_econtrollerelementtypebuttonmacro3 = 20 +k_econtrollerelementtypebuttonmacro4 = 21 +k_econtrollerelementtypebuttonmacro5 = 22 +k_econtrollerelementtypebuttonmacro6 = 23 +k_econtrollerelementtypebuttonmacro7 = 24 +k_econtrollerelementtypetrackpadcenter = 25 +k_econtrollerelementtypetrackpadleft = 26 +k_econtrollerelementtypetrackpadright = 27 +k_econtrollerelementtypekeyboard = 28 +k_econtrollerelementtypemagnifyingglass = 29 +k_econtrollerelementtypebuttonmacro1finger = 30 +k_econtrollerelementtypebuttonmacro2finger = 31 +k_econtrollerelementtyperecordinput = 32 +k_econtrollerelementtypeplaybackinput = 33 +k_econtrollerelementtypepaste = 34 +k_econtrollerelementtypemax = 35 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_econtrollerelementtype(e EControllerElementType, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_econtrollerelementtype(buf []byte, tag_wiretype vproto.WireType) ?(int, EControllerElementType) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EControllerElementType(v) +} +pub struct CVirtualControllerElement { +mut: +unknown_fields []vproto.UnknownField +pub mut: +@type EControllerElementType +has_type bool +visible bool +has_visible bool +x_position f32 +has_x_position bool +y_position f32 +has_y_position bool +x_scale f32 +has_x_scale bool +y_scale f32 +has_y_scale bool +} +pub fn (o &CVirtualControllerElement) pack() []byte { +mut res := []byte{} +if o.has_type { +res << zzz_vproto_internal_pack_econtrollerelementtype(o.@type, 1) +} + +if o.has_visible { +res << vproto.pack_bool_field(o.visible, 2) +} + +if o.has_x_position { +res << vproto.pack_float_field(o.x_position, 3) +} + +if o.has_y_position { +res << vproto.pack_float_field(o.y_position, 4) +} + +if o.has_x_scale { +res << vproto.pack_float_field(o.x_scale, 5) +} + +if o.has_y_scale { +res << vproto.pack_float_field(o.y_scale, 6) +} + +return res +} + +pub fn cvirtualcontrollerelement_unpack(buf []byte) ?CVirtualControllerElement { +mut res := CVirtualControllerElement{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_type = true +ii, v := zzz_vproto_internal_unpack_econtrollerelementtype(cur_buf, tag_wiretype.wire_type)? +res.@type = v +i = ii +} + +2 { +res.has_visible = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.visible = v +i = ii +} + +3 { +res.has_x_position = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.x_position = v +i = ii +} + +4 { +res.has_y_position = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.y_position = v +i = ii +} + +5 { +res.has_x_scale = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.x_scale = v +i = ii +} + +6 { +res.has_y_scale = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.y_scale = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cvirtualcontrollerelement() CVirtualControllerElement { +return CVirtualControllerElement{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cvirtualcontrollerelement(o CVirtualControllerElement, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cvirtualcontrollerelement(buf []byte, tag_wiretype vproto.WireType) ?(int, CVirtualControllerElement) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cvirtualcontrollerelement_unpack(v)? +return i, unpacked +} +pub struct CVirtualControllerColor { +mut: +unknown_fields []vproto.UnknownField +pub mut: +r f32 +has_r bool +g f32 +has_g bool +b f32 +has_b bool +a f32 +has_a bool +} +pub fn (o &CVirtualControllerColor) pack() []byte { +mut res := []byte{} +if o.has_r { +res << vproto.pack_float_field(o.r, 1) +} + +if o.has_g { +res << vproto.pack_float_field(o.g, 2) +} + +if o.has_b { +res << vproto.pack_float_field(o.b, 3) +} + +if o.has_a { +res << vproto.pack_float_field(o.a, 4) +} + +return res +} + +pub fn cvirtualcontrollercolor_unpack(buf []byte) ?CVirtualControllerColor { +mut res := CVirtualControllerColor{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_r = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.r = v +i = ii +} + +2 { +res.has_g = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.g = v +i = ii +} + +3 { +res.has_b = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.b = v +i = ii +} + +4 { +res.has_a = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.a = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cvirtualcontrollercolor() CVirtualControllerColor { +return CVirtualControllerColor{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cvirtualcontrollercolor(o CVirtualControllerColor, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cvirtualcontrollercolor(buf []byte, tag_wiretype vproto.WireType) ?(int, CVirtualControllerColor) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cvirtualcontrollercolor_unpack(v)? +return i, unpacked +} +pub struct CVirtualControllerLayout { +mut: +unknown_fields []vproto.UnknownField +pub mut: +layout_version int +has_layout_version bool +actionset_id int +has_actionset_id bool +elements []CVirtualControllerElement +color CVirtualControllerColor +has_color bool +} +pub fn (o &CVirtualControllerLayout) pack() []byte { +mut res := []byte{} +if o.has_layout_version { +res << vproto.pack_int32_field(o.layout_version, 1) +} + +if o.has_actionset_id { +res << vproto.pack_int32_field(o.actionset_id, 2) +} + +// [packed=false] +for _, x in o.elements { +res << zzz_vproto_internal_pack_cvirtualcontrollerelement(x, 4) +} + +if o.has_color { +res << zzz_vproto_internal_pack_cvirtualcontrollercolor(o.color, 5) +} + +return res +} + +pub fn cvirtualcontrollerlayout_unpack(buf []byte) ?CVirtualControllerLayout { +mut res := CVirtualControllerLayout{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_layout_version = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.layout_version = v +i = ii +} + +2 { +res.has_actionset_id = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.actionset_id = v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cvirtualcontrollerelement(cur_buf, tag_wiretype.wire_type)? +res.elements << v +i = ii +} + +5 { +res.has_color = true +ii, v := zzz_vproto_internal_unpack_cvirtualcontrollercolor(cur_buf, tag_wiretype.wire_type)? +res.color = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cvirtualcontrollerlayout() CVirtualControllerLayout { +return CVirtualControllerLayout{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cvirtualcontrollerlayout(o CVirtualControllerLayout, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cvirtualcontrollerlayout(buf []byte, tag_wiretype vproto.WireType) ?(int, CVirtualControllerLayout) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cvirtualcontrollerlayout_unpack(v)? +return i, unpacked +} +pub struct CVirtualControllerLayouts { +mut: +unknown_fields []vproto.UnknownField +pub mut: +layouts []CVirtualControllerLayout +input_mode EInputMode +has_input_mode bool +mouse_mode EMouseMode +has_mouse_mode bool +trackpad_sensitivity f32 +has_trackpad_sensitivity bool +pinch_zoom_enabled bool +has_pinch_zoom_enabled bool +pinch_zoom_x f32 +has_pinch_zoom_x bool +pinch_zoom_y f32 +has_pinch_zoom_y bool +pinch_zoom_scale f32 +has_pinch_zoom_scale bool +shaken bool +has_shaken bool +mouse_offscreen bool +has_mouse_offscreen bool +} +pub fn (o &CVirtualControllerLayouts) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.layouts { +res << zzz_vproto_internal_pack_cvirtualcontrollerlayout(x, 1) +} + +if o.has_input_mode { +res << zzz_vproto_internal_pack_einputmode(o.input_mode, 2) +} + +if o.has_mouse_mode { +res << zzz_vproto_internal_pack_emousemode(o.mouse_mode, 3) +} + +if o.has_trackpad_sensitivity { +res << vproto.pack_float_field(o.trackpad_sensitivity, 4) +} + +if o.has_pinch_zoom_enabled { +res << vproto.pack_bool_field(o.pinch_zoom_enabled, 5) +} + +if o.has_pinch_zoom_x { +res << vproto.pack_float_field(o.pinch_zoom_x, 6) +} + +if o.has_pinch_zoom_y { +res << vproto.pack_float_field(o.pinch_zoom_y, 7) +} + +if o.has_pinch_zoom_scale { +res << vproto.pack_float_field(o.pinch_zoom_scale, 8) +} + +if o.has_shaken { +res << vproto.pack_bool_field(o.shaken, 9) +} + +if o.has_mouse_offscreen { +res << vproto.pack_bool_field(o.mouse_offscreen, 10) +} + +return res +} + +pub fn cvirtualcontrollerlayouts_unpack(buf []byte) ?CVirtualControllerLayouts { +mut res := CVirtualControllerLayouts{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cvirtualcontrollerlayout(cur_buf, tag_wiretype.wire_type)? +res.layouts << v +i = ii +} + +2 { +res.has_input_mode = true +ii, v := zzz_vproto_internal_unpack_einputmode(cur_buf, tag_wiretype.wire_type)? +res.input_mode = v +i = ii +} + +3 { +res.has_mouse_mode = true +ii, v := zzz_vproto_internal_unpack_emousemode(cur_buf, tag_wiretype.wire_type)? +res.mouse_mode = v +i = ii +} + +4 { +res.has_trackpad_sensitivity = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.trackpad_sensitivity = v +i = ii +} + +5 { +res.has_pinch_zoom_enabled = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.pinch_zoom_enabled = v +i = ii +} + +6 { +res.has_pinch_zoom_x = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.pinch_zoom_x = v +i = ii +} + +7 { +res.has_pinch_zoom_y = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.pinch_zoom_y = v +i = ii +} + +8 { +res.has_pinch_zoom_scale = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.pinch_zoom_scale = v +i = ii +} + +9 { +res.has_shaken = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.shaken = v +i = ii +} + +10 { +res.has_mouse_offscreen = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.mouse_offscreen = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cvirtualcontrollerlayouts() CVirtualControllerLayouts { +return CVirtualControllerLayouts{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cvirtualcontrollerlayouts(o CVirtualControllerLayouts, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cvirtualcontrollerlayouts(buf []byte, tag_wiretype vproto.WireType) ?(int, CVirtualControllerLayouts) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cvirtualcontrollerlayouts_unpack(v)? +return i, unpacked +} +pub struct CVirtualControllerConfigControl { +mut: +unknown_fields []vproto.UnknownField +pub mut: +name string +has_name bool +icon string +has_icon bool +input_source int +has_input_source bool +input_mode int +has_input_mode bool +input_element int +has_input_element bool +output_gamepad int +has_output_gamepad bool +output_keyboard int +has_output_keyboard bool +output_mouse int +has_output_mouse bool +icon_foreground string +has_icon_foreground bool +icon_background string +has_icon_background bool +input_toggle bool +has_input_toggle bool +input_activate_stick_or_trackpad int +has_input_activate_stick_or_trackpad bool +activation_type int +has_activation_type bool +long_press_ms int +has_long_press_ms bool +double_press_ms int +has_double_press_ms bool +} +pub fn (o &CVirtualControllerConfigControl) pack() []byte { +mut res := []byte{} +if o.has_name { +res << vproto.pack_string_field(o.name, 1) +} + +if o.has_icon { +res << vproto.pack_string_field(o.icon, 2) +} + +if o.has_input_source { +res << vproto.pack_int32_field(o.input_source, 3) +} + +if o.has_input_mode { +res << vproto.pack_int32_field(o.input_mode, 4) +} + +if o.has_input_element { +res << vproto.pack_int32_field(o.input_element, 5) +} + +if o.has_output_gamepad { +res << vproto.pack_int32_field(o.output_gamepad, 6) +} + +if o.has_output_keyboard { +res << vproto.pack_int32_field(o.output_keyboard, 7) +} + +if o.has_output_mouse { +res << vproto.pack_int32_field(o.output_mouse, 8) +} + +if o.has_icon_foreground { +res << vproto.pack_string_field(o.icon_foreground, 9) +} + +if o.has_icon_background { +res << vproto.pack_string_field(o.icon_background, 10) +} + +if o.has_input_toggle { +res << vproto.pack_bool_field(o.input_toggle, 11) +} + +if o.has_input_activate_stick_or_trackpad { +res << vproto.pack_int32_field(o.input_activate_stick_or_trackpad, 12) +} + +if o.has_activation_type { +res << vproto.pack_int32_field(o.activation_type, 13) +} + +if o.has_long_press_ms { +res << vproto.pack_int32_field(o.long_press_ms, 14) +} + +if o.has_double_press_ms { +res << vproto.pack_int32_field(o.double_press_ms, 15) +} + +return res +} + +pub fn cvirtualcontrollerconfigcontrol_unpack(buf []byte) ?CVirtualControllerConfigControl { +mut res := CVirtualControllerConfigControl{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +2 { +res.has_icon = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.icon = v +i = ii +} + +3 { +res.has_input_source = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.input_source = v +i = ii +} + +4 { +res.has_input_mode = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.input_mode = v +i = ii +} + +5 { +res.has_input_element = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.input_element = v +i = ii +} + +6 { +res.has_output_gamepad = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.output_gamepad = v +i = ii +} + +7 { +res.has_output_keyboard = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.output_keyboard = v +i = ii +} + +8 { +res.has_output_mouse = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.output_mouse = v +i = ii +} + +9 { +res.has_icon_foreground = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.icon_foreground = v +i = ii +} + +10 { +res.has_icon_background = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.icon_background = v +i = ii +} + +11 { +res.has_input_toggle = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.input_toggle = v +i = ii +} + +12 { +res.has_input_activate_stick_or_trackpad = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.input_activate_stick_or_trackpad = v +i = ii +} + +13 { +res.has_activation_type = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.activation_type = v +i = ii +} + +14 { +res.has_long_press_ms = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.long_press_ms = v +i = ii +} + +15 { +res.has_double_press_ms = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.double_press_ms = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cvirtualcontrollerconfigcontrol() CVirtualControllerConfigControl { +return CVirtualControllerConfigControl{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cvirtualcontrollerconfigcontrol(o CVirtualControllerConfigControl, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cvirtualcontrollerconfigcontrol(buf []byte, tag_wiretype vproto.WireType) ?(int, CVirtualControllerConfigControl) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cvirtualcontrollerconfigcontrol_unpack(v)? +return i, unpacked +} +pub struct CVirtualControllerConfigActionSet { +mut: +unknown_fields []vproto.UnknownField +pub mut: +id int +has_id bool +parent_id int +has_parent_id bool +name string +has_name bool +controls []CVirtualControllerConfigControl +} +pub fn (o &CVirtualControllerConfigActionSet) pack() []byte { +mut res := []byte{} +if o.has_id { +res << vproto.pack_int32_field(o.id, 1) +} + +if o.has_parent_id { +res << vproto.pack_int32_field(o.parent_id, 2) +} + +if o.has_name { +res << vproto.pack_string_field(o.name, 3) +} + +// [packed=false] +for _, x in o.controls { +res << zzz_vproto_internal_pack_cvirtualcontrollerconfigcontrol(x, 4) +} + +return res +} + +pub fn cvirtualcontrollerconfigactionset_unpack(buf []byte) ?CVirtualControllerConfigActionSet { +mut res := CVirtualControllerConfigActionSet{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_id = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.id = v +i = ii +} + +2 { +res.has_parent_id = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.parent_id = v +i = ii +} + +3 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cvirtualcontrollerconfigcontrol(cur_buf, tag_wiretype.wire_type)? +res.controls << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cvirtualcontrollerconfigactionset() CVirtualControllerConfigActionSet { +return CVirtualControllerConfigActionSet{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cvirtualcontrollerconfigactionset(o CVirtualControllerConfigActionSet, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cvirtualcontrollerconfigactionset(buf []byte, tag_wiretype vproto.WireType) ?(int, CVirtualControllerConfigActionSet) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cvirtualcontrollerconfigactionset_unpack(v)? +return i, unpacked +} +pub struct CVirtualControllerConfig { +mut: +unknown_fields []vproto.UnknownField +pub mut: +name string +has_name bool +actionsets []CVirtualControllerConfigActionSet +default_mouse_mode EMouseMode +has_default_mouse_mode bool +} +pub fn (o &CVirtualControllerConfig) pack() []byte { +mut res := []byte{} +if o.has_name { +res << vproto.pack_string_field(o.name, 1) +} + +// [packed=false] +for _, x in o.actionsets { +res << zzz_vproto_internal_pack_cvirtualcontrollerconfigactionset(x, 2) +} + +if o.has_default_mouse_mode { +res << zzz_vproto_internal_pack_emousemode(o.default_mouse_mode, 3) +} + +return res +} + +pub fn cvirtualcontrollerconfig_unpack(buf []byte) ?CVirtualControllerConfig { +mut res := CVirtualControllerConfig{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_name = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.name = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cvirtualcontrollerconfigactionset(cur_buf, tag_wiretype.wire_type)? +res.actionsets << v +i = ii +} + +3 { +res.has_default_mouse_mode = true +ii, v := zzz_vproto_internal_unpack_emousemode(cur_buf, tag_wiretype.wire_type)? +res.default_mouse_mode = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cvirtualcontrollerconfig() CVirtualControllerConfig { +return CVirtualControllerConfig{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cvirtualcontrollerconfig(o CVirtualControllerConfig, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cvirtualcontrollerconfig(buf []byte, tag_wiretype vproto.WireType) ?(int, CVirtualControllerConfig) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cvirtualcontrollerconfig_unpack(v)? +return i, unpacked +} +pub struct CVirtualControllerLayoutPackage { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +creator u64 +has_creator bool +initial_revision u32 +has_initial_revision bool +saved_revision u32 +has_saved_revision bool +config CVirtualControllerConfig +has_config bool +layouts CVirtualControllerLayouts +has_layouts bool +} +pub fn (o &CVirtualControllerLayoutPackage) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_creator { +res << vproto.pack_uint64_field(o.creator, 2) +} + +if o.has_initial_revision { +res << vproto.pack_uint32_field(o.initial_revision, 3) +} + +if o.has_saved_revision { +res << vproto.pack_uint32_field(o.saved_revision, 4) +} + +if o.has_config { +res << zzz_vproto_internal_pack_cvirtualcontrollerconfig(o.config, 5) +} + +if o.has_layouts { +res << zzz_vproto_internal_pack_cvirtualcontrollerlayouts(o.layouts, 6) +} + +return res +} + +pub fn cvirtualcontrollerlayoutpackage_unpack(buf []byte) ?CVirtualControllerLayoutPackage { +mut res := CVirtualControllerLayoutPackage{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_creator = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.creator = v +i = ii +} + +3 { +res.has_initial_revision = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.initial_revision = v +i = ii +} + +4 { +res.has_saved_revision = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.saved_revision = v +i = ii +} + +5 { +res.has_config = true +ii, v := zzz_vproto_internal_unpack_cvirtualcontrollerconfig(cur_buf, tag_wiretype.wire_type)? +res.config = v +i = ii +} + +6 { +res.has_layouts = true +ii, v := zzz_vproto_internal_unpack_cvirtualcontrollerlayouts(cur_buf, tag_wiretype.wire_type)? +res.layouts = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cvirtualcontrollerlayoutpackage() CVirtualControllerLayoutPackage { +return CVirtualControllerLayoutPackage{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cvirtualcontrollerlayoutpackage(o CVirtualControllerLayoutPackage, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cvirtualcontrollerlayoutpackage(buf []byte, tag_wiretype vproto.WireType) ?(int, CVirtualControllerLayoutPackage) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cvirtualcontrollerlayoutpackage_unpack(v)? +return i, unpacked +} +pub struct CVirtualControllerGlobalConfig { +mut: +unknown_fields []vproto.UnknownField +pub mut: +feedback_enabled bool +has_feedback_enabled bool +gyroscope_enabled bool +has_gyroscope_enabled bool +auto_fade_enabled bool +has_auto_fade_enabled bool +rumble_enabled bool +has_rumble_enabled bool +shake_fade_enabled bool +has_shake_fade_enabled bool +} +pub fn (o &CVirtualControllerGlobalConfig) pack() []byte { +mut res := []byte{} +if o.has_feedback_enabled { +res << vproto.pack_bool_field(o.feedback_enabled, 1) +} + +if o.has_gyroscope_enabled { +res << vproto.pack_bool_field(o.gyroscope_enabled, 2) +} + +if o.has_auto_fade_enabled { +res << vproto.pack_bool_field(o.auto_fade_enabled, 3) +} + +if o.has_rumble_enabled { +res << vproto.pack_bool_field(o.rumble_enabled, 4) +} + +if o.has_shake_fade_enabled { +res << vproto.pack_bool_field(o.shake_fade_enabled, 5) +} + +return res +} + +pub fn cvirtualcontrollerglobalconfig_unpack(buf []byte) ?CVirtualControllerGlobalConfig { +mut res := CVirtualControllerGlobalConfig{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_feedback_enabled = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.feedback_enabled = v +i = ii +} + +2 { +res.has_gyroscope_enabled = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.gyroscope_enabled = v +i = ii +} + +3 { +res.has_auto_fade_enabled = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.auto_fade_enabled = v +i = ii +} + +4 { +res.has_rumble_enabled = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.rumble_enabled = v +i = ii +} + +5 { +res.has_shake_fade_enabled = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.shake_fade_enabled = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cvirtualcontrollerglobalconfig() CVirtualControllerGlobalConfig { +return CVirtualControllerGlobalConfig{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cvirtualcontrollerglobalconfig(o CVirtualControllerGlobalConfig, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cvirtualcontrollerglobalconfig(buf []byte, tag_wiretype vproto.WireType) ?(int, CVirtualControllerGlobalConfig) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cvirtualcontrollerglobalconfig_unpack(v)? +return i, unpacked +} diff --git a/proto/steamnetworkingsockets_messages_certs_pb.v b/proto/steamnetworkingsockets_messages_certs_pb.v new file mode 100644 index 0000000..81a19ff --- /dev/null +++ b/proto/steamnetworkingsockets_messages_certs_pb.v @@ -0,0 +1,448 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +pub struct CMsgSteamNetworkingIdentityLegacyBinary { +mut: +unknown_fields []vproto.UnknownField +pub mut: +steam_id u64 +has_steam_id bool +xbox_pairwise_id string +has_xbox_pairwise_id bool +generic_bytes []byte +has_generic_bytes bool +generic_string string +has_generic_string bool +ipv6_and_port []byte +has_ipv6_and_port bool +} +pub fn (o &CMsgSteamNetworkingIdentityLegacyBinary) pack() []byte { +mut res := []byte{} +if o.has_steam_id { +res << vproto.pack_64bit_field(o.steam_id, 16) +} + +if o.has_xbox_pairwise_id { +res << vproto.pack_string_field(o.xbox_pairwise_id, 17) +} + +if o.has_generic_bytes { +res << vproto.pack_bytes_field(o.generic_bytes, 2) +} + +if o.has_generic_string { +res << vproto.pack_string_field(o.generic_string, 3) +} + +if o.has_ipv6_and_port { +res << vproto.pack_bytes_field(o.ipv6_and_port, 4) +} + +return res +} + +pub fn cmsgsteamnetworkingidentitylegacybinary_unpack(buf []byte) ?CMsgSteamNetworkingIdentityLegacyBinary { +mut res := CMsgSteamNetworkingIdentityLegacyBinary{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +16 { +res.has_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.steam_id = v +i = ii +} + +17 { +res.has_xbox_pairwise_id = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.xbox_pairwise_id = v +i = ii +} + +2 { +res.has_generic_bytes = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.generic_bytes = v +i = ii +} + +3 { +res.has_generic_string = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.generic_string = v +i = ii +} + +4 { +res.has_ipv6_and_port = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.ipv6_and_port = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamnetworkingidentitylegacybinary() CMsgSteamNetworkingIdentityLegacyBinary { +return CMsgSteamNetworkingIdentityLegacyBinary{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamnetworkingidentitylegacybinary(o CMsgSteamNetworkingIdentityLegacyBinary, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamnetworkingidentitylegacybinary(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamNetworkingIdentityLegacyBinary) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamnetworkingidentitylegacybinary_unpack(v)? +return i, unpacked +} +[_allow_multiple_values] +enum CMsgSteamDatagramCertificateEKeyType { +invalid = 0 +ed25519 = 1 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_cmsgsteamdatagramcertificateekeytype(e CMsgSteamDatagramCertificateEKeyType, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_cmsgsteamdatagramcertificateekeytype(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramCertificateEKeyType) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, CMsgSteamDatagramCertificateEKeyType(v) +} +pub struct CMsgSteamDatagramCertificate { +mut: +unknown_fields []vproto.UnknownField +pub mut: +key_type CMsgSteamDatagramCertificateEKeyType +has_key_type bool +key_data []byte +has_key_data bool +legacy_steam_id u64 +has_legacy_steam_id bool +legacy_identity_binary CMsgSteamNetworkingIdentityLegacyBinary +has_legacy_identity_binary bool +identity_string string +has_identity_string bool +gameserver_datacenter_ids []u32 +time_created u32 +has_time_created bool +time_expiry u32 +has_time_expiry bool +app_ids []u32 +} +pub fn (o &CMsgSteamDatagramCertificate) pack() []byte { +mut res := []byte{} +if o.has_key_type { +res << zzz_vproto_internal_pack_cmsgsteamdatagramcertificateekeytype(o.key_type, 1) +} + +if o.has_key_data { +res << vproto.pack_bytes_field(o.key_data, 2) +} + +if o.has_legacy_steam_id { +res << vproto.pack_64bit_field(o.legacy_steam_id, 4) +} + +if o.has_legacy_identity_binary { +res << zzz_vproto_internal_pack_cmsgsteamnetworkingidentitylegacybinary(o.legacy_identity_binary, 11) +} + +if o.has_identity_string { +res << vproto.pack_string_field(o.identity_string, 12) +} + +// [packed=false] +for _, x in o.gameserver_datacenter_ids { +res << vproto.pack_32bit_field(x, 5) +} + +if o.has_time_created { +res << vproto.pack_32bit_field(o.time_created, 8) +} + +if o.has_time_expiry { +res << vproto.pack_32bit_field(o.time_expiry, 9) +} + +// [packed=false] +for _, x in o.app_ids { +res << vproto.pack_uint32_field(x, 10) +} + +return res +} + +pub fn cmsgsteamdatagramcertificate_unpack(buf []byte) ?CMsgSteamDatagramCertificate { +mut res := CMsgSteamDatagramCertificate{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_key_type = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramcertificateekeytype(cur_buf, tag_wiretype.wire_type)? +res.key_type = v +i = ii +} + +2 { +res.has_key_data = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.key_data = v +i = ii +} + +4 { +res.has_legacy_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.legacy_steam_id = v +i = ii +} + +11 { +res.has_legacy_identity_binary = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamnetworkingidentitylegacybinary(cur_buf, tag_wiretype.wire_type)? +res.legacy_identity_binary = v +i = ii +} + +12 { +res.has_identity_string = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.identity_string = v +i = ii +} + +5 { +// [packed=false] +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.gameserver_datacenter_ids << v +i = ii +} + +8 { +res.has_time_created = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.time_created = v +i = ii +} + +9 { +res.has_time_expiry = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.time_expiry = v +i = ii +} + +10 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.app_ids << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramcertificate() CMsgSteamDatagramCertificate { +return CMsgSteamDatagramCertificate{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramcertificate(o CMsgSteamDatagramCertificate, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramcertificate(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramCertificate) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramcertificate_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramCertificateSigned { +mut: +unknown_fields []vproto.UnknownField +pub mut: +cert []byte +has_cert bool +ca_key_id u64 +has_ca_key_id bool +ca_signature []byte +has_ca_signature bool +private_key_data []byte +has_private_key_data bool +} +pub fn (o &CMsgSteamDatagramCertificateSigned) pack() []byte { +mut res := []byte{} +if o.has_cert { +res << vproto.pack_bytes_field(o.cert, 4) +} + +if o.has_ca_key_id { +res << vproto.pack_64bit_field(o.ca_key_id, 5) +} + +if o.has_ca_signature { +res << vproto.pack_bytes_field(o.ca_signature, 6) +} + +if o.has_private_key_data { +res << vproto.pack_bytes_field(o.private_key_data, 1) +} + +return res +} + +pub fn cmsgsteamdatagramcertificatesigned_unpack(buf []byte) ?CMsgSteamDatagramCertificateSigned { +mut res := CMsgSteamDatagramCertificateSigned{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +4 { +res.has_cert = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.cert = v +i = ii +} + +5 { +res.has_ca_key_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.ca_key_id = v +i = ii +} + +6 { +res.has_ca_signature = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.ca_signature = v +i = ii +} + +1 { +res.has_private_key_data = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.private_key_data = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramcertificatesigned() CMsgSteamDatagramCertificateSigned { +return CMsgSteamDatagramCertificateSigned{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramcertificatesigned(o CMsgSteamDatagramCertificateSigned, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramcertificatesigned(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramCertificateSigned) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramcertificatesigned_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramCertificateRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +cert CMsgSteamDatagramCertificate +has_cert bool +} +pub fn (o &CMsgSteamDatagramCertificateRequest) pack() []byte { +mut res := []byte{} +if o.has_cert { +res << zzz_vproto_internal_pack_cmsgsteamdatagramcertificate(o.cert, 1) +} + +return res +} + +pub fn cmsgsteamdatagramcertificaterequest_unpack(buf []byte) ?CMsgSteamDatagramCertificateRequest { +mut res := CMsgSteamDatagramCertificateRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_cert = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramcertificate(cur_buf, tag_wiretype.wire_type)? +res.cert = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramcertificaterequest() CMsgSteamDatagramCertificateRequest { +return CMsgSteamDatagramCertificateRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramcertificaterequest(o CMsgSteamDatagramCertificateRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramcertificaterequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramCertificateRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramcertificaterequest_unpack(v)? +return i, unpacked +} diff --git a/proto/steamnetworkingsockets_messages_pb.v b/proto/steamnetworkingsockets_messages_pb.v new file mode 100644 index 0000000..3761856 --- /dev/null +++ b/proto/steamnetworkingsockets_messages_pb.v @@ -0,0 +1,2310 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +[_allow_multiple_values] +enum ESteamNetworkingSocketsCipher { +k_esteamnetworkingsocketscipher_invalid = 0 +k_esteamnetworkingsocketscipher_null = 1 +k_esteamnetworkingsocketscipher_aes_256_gcm = 2 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_esteamnetworkingsocketscipher(e ESteamNetworkingSocketsCipher, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_esteamnetworkingsocketscipher(buf []byte, tag_wiretype vproto.WireType) ?(int, ESteamNetworkingSocketsCipher) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, ESteamNetworkingSocketsCipher(v) +} +[_allow_multiple_values] +enum CMsgSteamDatagramSessionCryptInfoEKeyType { +invalid = 0 +curve25519 = 1 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_cmsgsteamdatagramsessioncryptinfoekeytype(e CMsgSteamDatagramSessionCryptInfoEKeyType, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_cmsgsteamdatagramsessioncryptinfoekeytype(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramSessionCryptInfoEKeyType) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, CMsgSteamDatagramSessionCryptInfoEKeyType(v) +} +pub struct CMsgSteamDatagramSessionCryptInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +key_type CMsgSteamDatagramSessionCryptInfoEKeyType +has_key_type bool +key_data []byte +has_key_data bool +nonce u64 +has_nonce bool +protocol_version u32 +has_protocol_version bool +ciphers []ESteamNetworkingSocketsCipher +} +pub fn (o &CMsgSteamDatagramSessionCryptInfo) pack() []byte { +mut res := []byte{} +if o.has_key_type { +res << zzz_vproto_internal_pack_cmsgsteamdatagramsessioncryptinfoekeytype(o.key_type, 1) +} + +if o.has_key_data { +res << vproto.pack_bytes_field(o.key_data, 2) +} + +if o.has_nonce { +res << vproto.pack_64bit_field(o.nonce, 3) +} + +if o.has_protocol_version { +res << vproto.pack_uint32_field(o.protocol_version, 4) +} + +// [packed=false] +for _, x in o.ciphers { +res << zzz_vproto_internal_pack_esteamnetworkingsocketscipher(x, 5) +} + +return res +} + +pub fn cmsgsteamdatagramsessioncryptinfo_unpack(buf []byte) ?CMsgSteamDatagramSessionCryptInfo { +mut res := CMsgSteamDatagramSessionCryptInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_key_type = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramsessioncryptinfoekeytype(cur_buf, tag_wiretype.wire_type)? +res.key_type = v +i = ii +} + +2 { +res.has_key_data = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.key_data = v +i = ii +} + +3 { +res.has_nonce = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.nonce = v +i = ii +} + +4 { +res.has_protocol_version = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.protocol_version = v +i = ii +} + +5 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_esteamnetworkingsocketscipher(cur_buf, tag_wiretype.wire_type)? +res.ciphers << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramsessioncryptinfo() CMsgSteamDatagramSessionCryptInfo { +return CMsgSteamDatagramSessionCryptInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramsessioncryptinfo(o CMsgSteamDatagramSessionCryptInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramsessioncryptinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramSessionCryptInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramsessioncryptinfo_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramSessionCryptInfoSigned { +mut: +unknown_fields []vproto.UnknownField +pub mut: +info []byte +has_info bool +signature []byte +has_signature bool +} +pub fn (o &CMsgSteamDatagramSessionCryptInfoSigned) pack() []byte { +mut res := []byte{} +if o.has_info { +res << vproto.pack_bytes_field(o.info, 1) +} + +if o.has_signature { +res << vproto.pack_bytes_field(o.signature, 2) +} + +return res +} + +pub fn cmsgsteamdatagramsessioncryptinfosigned_unpack(buf []byte) ?CMsgSteamDatagramSessionCryptInfoSigned { +mut res := CMsgSteamDatagramSessionCryptInfoSigned{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_info = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.info = v +i = ii +} + +2 { +res.has_signature = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.signature = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramsessioncryptinfosigned() CMsgSteamDatagramSessionCryptInfoSigned { +return CMsgSteamDatagramSessionCryptInfoSigned{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramsessioncryptinfosigned(o CMsgSteamDatagramSessionCryptInfoSigned, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramsessioncryptinfosigned(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramSessionCryptInfoSigned) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramsessioncryptinfosigned_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramDiagnostic { +mut: +unknown_fields []vproto.UnknownField +pub mut: +severity u32 +has_severity bool +text string +has_text bool +} +pub fn (o &CMsgSteamDatagramDiagnostic) pack() []byte { +mut res := []byte{} +if o.has_severity { +res << vproto.pack_uint32_field(o.severity, 1) +} + +if o.has_text { +res << vproto.pack_string_field(o.text, 2) +} + +return res +} + +pub fn cmsgsteamdatagramdiagnostic_unpack(buf []byte) ?CMsgSteamDatagramDiagnostic { +mut res := CMsgSteamDatagramDiagnostic{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_severity = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.severity = v +i = ii +} + +2 { +res.has_text = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.text = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramdiagnostic() CMsgSteamDatagramDiagnostic { +return CMsgSteamDatagramDiagnostic{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramdiagnostic(o CMsgSteamDatagramDiagnostic, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramdiagnostic(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramDiagnostic) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramdiagnostic_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramLinkInstantaneousStats { +mut: +unknown_fields []vproto.UnknownField +pub mut: +out_packets_per_sec_x10 u32 +has_out_packets_per_sec_x10 bool +out_bytes_per_sec u32 +has_out_bytes_per_sec bool +in_packets_per_sec_x10 u32 +has_in_packets_per_sec_x10 bool +in_bytes_per_sec u32 +has_in_bytes_per_sec bool +ping_ms u32 +has_ping_ms bool +packets_dropped_pct u32 +has_packets_dropped_pct bool +packets_weird_sequence_pct u32 +has_packets_weird_sequence_pct bool +peak_jitter_usec u32 +has_peak_jitter_usec bool +} +pub fn (o &CMsgSteamDatagramLinkInstantaneousStats) pack() []byte { +mut res := []byte{} +if o.has_out_packets_per_sec_x10 { +res << vproto.pack_uint32_field(o.out_packets_per_sec_x10, 1) +} + +if o.has_out_bytes_per_sec { +res << vproto.pack_uint32_field(o.out_bytes_per_sec, 2) +} + +if o.has_in_packets_per_sec_x10 { +res << vproto.pack_uint32_field(o.in_packets_per_sec_x10, 3) +} + +if o.has_in_bytes_per_sec { +res << vproto.pack_uint32_field(o.in_bytes_per_sec, 4) +} + +if o.has_ping_ms { +res << vproto.pack_uint32_field(o.ping_ms, 5) +} + +if o.has_packets_dropped_pct { +res << vproto.pack_uint32_field(o.packets_dropped_pct, 6) +} + +if o.has_packets_weird_sequence_pct { +res << vproto.pack_uint32_field(o.packets_weird_sequence_pct, 7) +} + +if o.has_peak_jitter_usec { +res << vproto.pack_uint32_field(o.peak_jitter_usec, 8) +} + +return res +} + +pub fn cmsgsteamdatagramlinkinstantaneousstats_unpack(buf []byte) ?CMsgSteamDatagramLinkInstantaneousStats { +mut res := CMsgSteamDatagramLinkInstantaneousStats{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_out_packets_per_sec_x10 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.out_packets_per_sec_x10 = v +i = ii +} + +2 { +res.has_out_bytes_per_sec = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.out_bytes_per_sec = v +i = ii +} + +3 { +res.has_in_packets_per_sec_x10 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.in_packets_per_sec_x10 = v +i = ii +} + +4 { +res.has_in_bytes_per_sec = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.in_bytes_per_sec = v +i = ii +} + +5 { +res.has_ping_ms = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ping_ms = v +i = ii +} + +6 { +res.has_packets_dropped_pct = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.packets_dropped_pct = v +i = ii +} + +7 { +res.has_packets_weird_sequence_pct = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.packets_weird_sequence_pct = v +i = ii +} + +8 { +res.has_peak_jitter_usec = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.peak_jitter_usec = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramlinkinstantaneousstats() CMsgSteamDatagramLinkInstantaneousStats { +return CMsgSteamDatagramLinkInstantaneousStats{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramlinkinstantaneousstats(o CMsgSteamDatagramLinkInstantaneousStats, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramlinkinstantaneousstats(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramLinkInstantaneousStats) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramlinkinstantaneousstats_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramLinkLifetimeStats { +mut: +unknown_fields []vproto.UnknownField +pub mut: +connected_seconds u32 +has_connected_seconds bool +packets_sent u64 +has_packets_sent bool +kb_sent u64 +has_kb_sent bool +packets_recv u64 +has_packets_recv bool +kb_recv u64 +has_kb_recv bool +packets_recv_sequenced u64 +has_packets_recv_sequenced bool +packets_recv_dropped u64 +has_packets_recv_dropped bool +packets_recv_out_of_order u64 +has_packets_recv_out_of_order bool +packets_recv_duplicate u64 +has_packets_recv_duplicate bool +packets_recv_lurch u64 +has_packets_recv_lurch bool +quality_histogram_100 u32 +has_quality_histogram_100 bool +quality_histogram_99 u32 +has_quality_histogram_99 bool +quality_histogram_97 u32 +has_quality_histogram_97 bool +quality_histogram_95 u32 +has_quality_histogram_95 bool +quality_histogram_90 u32 +has_quality_histogram_90 bool +quality_histogram_75 u32 +has_quality_histogram_75 bool +quality_histogram_50 u32 +has_quality_histogram_50 bool +quality_histogram_1 u32 +has_quality_histogram_1 bool +quality_histogram_dead u32 +has_quality_histogram_dead bool +quality_ntile_2nd u32 +has_quality_ntile_2nd bool +quality_ntile_5th u32 +has_quality_ntile_5th bool +quality_ntile_25th u32 +has_quality_ntile_25th bool +quality_ntile_50th u32 +has_quality_ntile_50th bool +ping_histogram_25 u32 +has_ping_histogram_25 bool +ping_histogram_50 u32 +has_ping_histogram_50 bool +ping_histogram_75 u32 +has_ping_histogram_75 bool +ping_histogram_100 u32 +has_ping_histogram_100 bool +ping_histogram_125 u32 +has_ping_histogram_125 bool +ping_histogram_150 u32 +has_ping_histogram_150 bool +ping_histogram_200 u32 +has_ping_histogram_200 bool +ping_histogram_300 u32 +has_ping_histogram_300 bool +ping_histogram_max u32 +has_ping_histogram_max bool +ping_ntile_5th u32 +has_ping_ntile_5th bool +ping_ntile_50th u32 +has_ping_ntile_50th bool +ping_ntile_75th u32 +has_ping_ntile_75th bool +ping_ntile_95th u32 +has_ping_ntile_95th bool +ping_ntile_98th u32 +has_ping_ntile_98th bool +jitter_histogram_negligible u32 +has_jitter_histogram_negligible bool +jitter_histogram_1 u32 +has_jitter_histogram_1 bool +jitter_histogram_2 u32 +has_jitter_histogram_2 bool +jitter_histogram_5 u32 +has_jitter_histogram_5 bool +jitter_histogram_10 u32 +has_jitter_histogram_10 bool +jitter_histogram_20 u32 +has_jitter_histogram_20 bool +txspeed_max u32 +has_txspeed_max bool +txspeed_histogram_16 u32 +has_txspeed_histogram_16 bool +txspeed_histogram_32 u32 +has_txspeed_histogram_32 bool +txspeed_histogram_64 u32 +has_txspeed_histogram_64 bool +txspeed_histogram_128 u32 +has_txspeed_histogram_128 bool +txspeed_histogram_256 u32 +has_txspeed_histogram_256 bool +txspeed_histogram_512 u32 +has_txspeed_histogram_512 bool +txspeed_histogram_1024 u32 +has_txspeed_histogram_1024 bool +txspeed_histogram_max u32 +has_txspeed_histogram_max bool +txspeed_ntile_5th u32 +has_txspeed_ntile_5th bool +txspeed_ntile_50th u32 +has_txspeed_ntile_50th bool +txspeed_ntile_75th u32 +has_txspeed_ntile_75th bool +txspeed_ntile_95th u32 +has_txspeed_ntile_95th bool +txspeed_ntile_98th u32 +has_txspeed_ntile_98th bool +rxspeed_max u32 +has_rxspeed_max bool +rxspeed_histogram_16 u32 +has_rxspeed_histogram_16 bool +rxspeed_histogram_32 u32 +has_rxspeed_histogram_32 bool +rxspeed_histogram_64 u32 +has_rxspeed_histogram_64 bool +rxspeed_histogram_128 u32 +has_rxspeed_histogram_128 bool +rxspeed_histogram_256 u32 +has_rxspeed_histogram_256 bool +rxspeed_histogram_512 u32 +has_rxspeed_histogram_512 bool +rxspeed_histogram_1024 u32 +has_rxspeed_histogram_1024 bool +rxspeed_histogram_max u32 +has_rxspeed_histogram_max bool +rxspeed_ntile_5th u32 +has_rxspeed_ntile_5th bool +rxspeed_ntile_50th u32 +has_rxspeed_ntile_50th bool +rxspeed_ntile_75th u32 +has_rxspeed_ntile_75th bool +rxspeed_ntile_95th u32 +has_rxspeed_ntile_95th bool +rxspeed_ntile_98th u32 +has_rxspeed_ntile_98th bool +} +pub fn (o &CMsgSteamDatagramLinkLifetimeStats) pack() []byte { +mut res := []byte{} +if o.has_connected_seconds { +res << vproto.pack_uint32_field(o.connected_seconds, 2) +} + +if o.has_packets_sent { +res << vproto.pack_uint64_field(o.packets_sent, 3) +} + +if o.has_kb_sent { +res << vproto.pack_uint64_field(o.kb_sent, 4) +} + +if o.has_packets_recv { +res << vproto.pack_uint64_field(o.packets_recv, 5) +} + +if o.has_kb_recv { +res << vproto.pack_uint64_field(o.kb_recv, 6) +} + +if o.has_packets_recv_sequenced { +res << vproto.pack_uint64_field(o.packets_recv_sequenced, 7) +} + +if o.has_packets_recv_dropped { +res << vproto.pack_uint64_field(o.packets_recv_dropped, 8) +} + +if o.has_packets_recv_out_of_order { +res << vproto.pack_uint64_field(o.packets_recv_out_of_order, 9) +} + +if o.has_packets_recv_duplicate { +res << vproto.pack_uint64_field(o.packets_recv_duplicate, 10) +} + +if o.has_packets_recv_lurch { +res << vproto.pack_uint64_field(o.packets_recv_lurch, 11) +} + +if o.has_quality_histogram_100 { +res << vproto.pack_uint32_field(o.quality_histogram_100, 21) +} + +if o.has_quality_histogram_99 { +res << vproto.pack_uint32_field(o.quality_histogram_99, 22) +} + +if o.has_quality_histogram_97 { +res << vproto.pack_uint32_field(o.quality_histogram_97, 23) +} + +if o.has_quality_histogram_95 { +res << vproto.pack_uint32_field(o.quality_histogram_95, 24) +} + +if o.has_quality_histogram_90 { +res << vproto.pack_uint32_field(o.quality_histogram_90, 25) +} + +if o.has_quality_histogram_75 { +res << vproto.pack_uint32_field(o.quality_histogram_75, 26) +} + +if o.has_quality_histogram_50 { +res << vproto.pack_uint32_field(o.quality_histogram_50, 27) +} + +if o.has_quality_histogram_1 { +res << vproto.pack_uint32_field(o.quality_histogram_1, 28) +} + +if o.has_quality_histogram_dead { +res << vproto.pack_uint32_field(o.quality_histogram_dead, 29) +} + +if o.has_quality_ntile_2nd { +res << vproto.pack_uint32_field(o.quality_ntile_2nd, 30) +} + +if o.has_quality_ntile_5th { +res << vproto.pack_uint32_field(o.quality_ntile_5th, 31) +} + +if o.has_quality_ntile_25th { +res << vproto.pack_uint32_field(o.quality_ntile_25th, 32) +} + +if o.has_quality_ntile_50th { +res << vproto.pack_uint32_field(o.quality_ntile_50th, 33) +} + +if o.has_ping_histogram_25 { +res << vproto.pack_uint32_field(o.ping_histogram_25, 41) +} + +if o.has_ping_histogram_50 { +res << vproto.pack_uint32_field(o.ping_histogram_50, 42) +} + +if o.has_ping_histogram_75 { +res << vproto.pack_uint32_field(o.ping_histogram_75, 43) +} + +if o.has_ping_histogram_100 { +res << vproto.pack_uint32_field(o.ping_histogram_100, 44) +} + +if o.has_ping_histogram_125 { +res << vproto.pack_uint32_field(o.ping_histogram_125, 45) +} + +if o.has_ping_histogram_150 { +res << vproto.pack_uint32_field(o.ping_histogram_150, 46) +} + +if o.has_ping_histogram_200 { +res << vproto.pack_uint32_field(o.ping_histogram_200, 47) +} + +if o.has_ping_histogram_300 { +res << vproto.pack_uint32_field(o.ping_histogram_300, 48) +} + +if o.has_ping_histogram_max { +res << vproto.pack_uint32_field(o.ping_histogram_max, 49) +} + +if o.has_ping_ntile_5th { +res << vproto.pack_uint32_field(o.ping_ntile_5th, 50) +} + +if o.has_ping_ntile_50th { +res << vproto.pack_uint32_field(o.ping_ntile_50th, 51) +} + +if o.has_ping_ntile_75th { +res << vproto.pack_uint32_field(o.ping_ntile_75th, 52) +} + +if o.has_ping_ntile_95th { +res << vproto.pack_uint32_field(o.ping_ntile_95th, 53) +} + +if o.has_ping_ntile_98th { +res << vproto.pack_uint32_field(o.ping_ntile_98th, 54) +} + +if o.has_jitter_histogram_negligible { +res << vproto.pack_uint32_field(o.jitter_histogram_negligible, 61) +} + +if o.has_jitter_histogram_1 { +res << vproto.pack_uint32_field(o.jitter_histogram_1, 62) +} + +if o.has_jitter_histogram_2 { +res << vproto.pack_uint32_field(o.jitter_histogram_2, 63) +} + +if o.has_jitter_histogram_5 { +res << vproto.pack_uint32_field(o.jitter_histogram_5, 64) +} + +if o.has_jitter_histogram_10 { +res << vproto.pack_uint32_field(o.jitter_histogram_10, 65) +} + +if o.has_jitter_histogram_20 { +res << vproto.pack_uint32_field(o.jitter_histogram_20, 66) +} + +if o.has_txspeed_max { +res << vproto.pack_uint32_field(o.txspeed_max, 67) +} + +if o.has_txspeed_histogram_16 { +res << vproto.pack_uint32_field(o.txspeed_histogram_16, 68) +} + +if o.has_txspeed_histogram_32 { +res << vproto.pack_uint32_field(o.txspeed_histogram_32, 69) +} + +if o.has_txspeed_histogram_64 { +res << vproto.pack_uint32_field(o.txspeed_histogram_64, 70) +} + +if o.has_txspeed_histogram_128 { +res << vproto.pack_uint32_field(o.txspeed_histogram_128, 71) +} + +if o.has_txspeed_histogram_256 { +res << vproto.pack_uint32_field(o.txspeed_histogram_256, 72) +} + +if o.has_txspeed_histogram_512 { +res << vproto.pack_uint32_field(o.txspeed_histogram_512, 73) +} + +if o.has_txspeed_histogram_1024 { +res << vproto.pack_uint32_field(o.txspeed_histogram_1024, 74) +} + +if o.has_txspeed_histogram_max { +res << vproto.pack_uint32_field(o.txspeed_histogram_max, 75) +} + +if o.has_txspeed_ntile_5th { +res << vproto.pack_uint32_field(o.txspeed_ntile_5th, 76) +} + +if o.has_txspeed_ntile_50th { +res << vproto.pack_uint32_field(o.txspeed_ntile_50th, 77) +} + +if o.has_txspeed_ntile_75th { +res << vproto.pack_uint32_field(o.txspeed_ntile_75th, 78) +} + +if o.has_txspeed_ntile_95th { +res << vproto.pack_uint32_field(o.txspeed_ntile_95th, 79) +} + +if o.has_txspeed_ntile_98th { +res << vproto.pack_uint32_field(o.txspeed_ntile_98th, 80) +} + +if o.has_rxspeed_max { +res << vproto.pack_uint32_field(o.rxspeed_max, 81) +} + +if o.has_rxspeed_histogram_16 { +res << vproto.pack_uint32_field(o.rxspeed_histogram_16, 82) +} + +if o.has_rxspeed_histogram_32 { +res << vproto.pack_uint32_field(o.rxspeed_histogram_32, 83) +} + +if o.has_rxspeed_histogram_64 { +res << vproto.pack_uint32_field(o.rxspeed_histogram_64, 84) +} + +if o.has_rxspeed_histogram_128 { +res << vproto.pack_uint32_field(o.rxspeed_histogram_128, 85) +} + +if o.has_rxspeed_histogram_256 { +res << vproto.pack_uint32_field(o.rxspeed_histogram_256, 86) +} + +if o.has_rxspeed_histogram_512 { +res << vproto.pack_uint32_field(o.rxspeed_histogram_512, 87) +} + +if o.has_rxspeed_histogram_1024 { +res << vproto.pack_uint32_field(o.rxspeed_histogram_1024, 88) +} + +if o.has_rxspeed_histogram_max { +res << vproto.pack_uint32_field(o.rxspeed_histogram_max, 89) +} + +if o.has_rxspeed_ntile_5th { +res << vproto.pack_uint32_field(o.rxspeed_ntile_5th, 90) +} + +if o.has_rxspeed_ntile_50th { +res << vproto.pack_uint32_field(o.rxspeed_ntile_50th, 91) +} + +if o.has_rxspeed_ntile_75th { +res << vproto.pack_uint32_field(o.rxspeed_ntile_75th, 92) +} + +if o.has_rxspeed_ntile_95th { +res << vproto.pack_uint32_field(o.rxspeed_ntile_95th, 93) +} + +if o.has_rxspeed_ntile_98th { +res << vproto.pack_uint32_field(o.rxspeed_ntile_98th, 94) +} + +return res +} + +pub fn cmsgsteamdatagramlinklifetimestats_unpack(buf []byte) ?CMsgSteamDatagramLinkLifetimeStats { +mut res := CMsgSteamDatagramLinkLifetimeStats{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +2 { +res.has_connected_seconds = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.connected_seconds = v +i = ii +} + +3 { +res.has_packets_sent = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.packets_sent = v +i = ii +} + +4 { +res.has_kb_sent = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.kb_sent = v +i = ii +} + +5 { +res.has_packets_recv = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.packets_recv = v +i = ii +} + +6 { +res.has_kb_recv = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.kb_recv = v +i = ii +} + +7 { +res.has_packets_recv_sequenced = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.packets_recv_sequenced = v +i = ii +} + +8 { +res.has_packets_recv_dropped = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.packets_recv_dropped = v +i = ii +} + +9 { +res.has_packets_recv_out_of_order = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.packets_recv_out_of_order = v +i = ii +} + +10 { +res.has_packets_recv_duplicate = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.packets_recv_duplicate = v +i = ii +} + +11 { +res.has_packets_recv_lurch = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.packets_recv_lurch = v +i = ii +} + +21 { +res.has_quality_histogram_100 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.quality_histogram_100 = v +i = ii +} + +22 { +res.has_quality_histogram_99 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.quality_histogram_99 = v +i = ii +} + +23 { +res.has_quality_histogram_97 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.quality_histogram_97 = v +i = ii +} + +24 { +res.has_quality_histogram_95 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.quality_histogram_95 = v +i = ii +} + +25 { +res.has_quality_histogram_90 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.quality_histogram_90 = v +i = ii +} + +26 { +res.has_quality_histogram_75 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.quality_histogram_75 = v +i = ii +} + +27 { +res.has_quality_histogram_50 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.quality_histogram_50 = v +i = ii +} + +28 { +res.has_quality_histogram_1 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.quality_histogram_1 = v +i = ii +} + +29 { +res.has_quality_histogram_dead = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.quality_histogram_dead = v +i = ii +} + +30 { +res.has_quality_ntile_2nd = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.quality_ntile_2nd = v +i = ii +} + +31 { +res.has_quality_ntile_5th = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.quality_ntile_5th = v +i = ii +} + +32 { +res.has_quality_ntile_25th = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.quality_ntile_25th = v +i = ii +} + +33 { +res.has_quality_ntile_50th = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.quality_ntile_50th = v +i = ii +} + +41 { +res.has_ping_histogram_25 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ping_histogram_25 = v +i = ii +} + +42 { +res.has_ping_histogram_50 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ping_histogram_50 = v +i = ii +} + +43 { +res.has_ping_histogram_75 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ping_histogram_75 = v +i = ii +} + +44 { +res.has_ping_histogram_100 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ping_histogram_100 = v +i = ii +} + +45 { +res.has_ping_histogram_125 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ping_histogram_125 = v +i = ii +} + +46 { +res.has_ping_histogram_150 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ping_histogram_150 = v +i = ii +} + +47 { +res.has_ping_histogram_200 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ping_histogram_200 = v +i = ii +} + +48 { +res.has_ping_histogram_300 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ping_histogram_300 = v +i = ii +} + +49 { +res.has_ping_histogram_max = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ping_histogram_max = v +i = ii +} + +50 { +res.has_ping_ntile_5th = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ping_ntile_5th = v +i = ii +} + +51 { +res.has_ping_ntile_50th = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ping_ntile_50th = v +i = ii +} + +52 { +res.has_ping_ntile_75th = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ping_ntile_75th = v +i = ii +} + +53 { +res.has_ping_ntile_95th = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ping_ntile_95th = v +i = ii +} + +54 { +res.has_ping_ntile_98th = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ping_ntile_98th = v +i = ii +} + +61 { +res.has_jitter_histogram_negligible = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.jitter_histogram_negligible = v +i = ii +} + +62 { +res.has_jitter_histogram_1 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.jitter_histogram_1 = v +i = ii +} + +63 { +res.has_jitter_histogram_2 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.jitter_histogram_2 = v +i = ii +} + +64 { +res.has_jitter_histogram_5 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.jitter_histogram_5 = v +i = ii +} + +65 { +res.has_jitter_histogram_10 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.jitter_histogram_10 = v +i = ii +} + +66 { +res.has_jitter_histogram_20 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.jitter_histogram_20 = v +i = ii +} + +67 { +res.has_txspeed_max = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.txspeed_max = v +i = ii +} + +68 { +res.has_txspeed_histogram_16 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.txspeed_histogram_16 = v +i = ii +} + +69 { +res.has_txspeed_histogram_32 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.txspeed_histogram_32 = v +i = ii +} + +70 { +res.has_txspeed_histogram_64 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.txspeed_histogram_64 = v +i = ii +} + +71 { +res.has_txspeed_histogram_128 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.txspeed_histogram_128 = v +i = ii +} + +72 { +res.has_txspeed_histogram_256 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.txspeed_histogram_256 = v +i = ii +} + +73 { +res.has_txspeed_histogram_512 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.txspeed_histogram_512 = v +i = ii +} + +74 { +res.has_txspeed_histogram_1024 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.txspeed_histogram_1024 = v +i = ii +} + +75 { +res.has_txspeed_histogram_max = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.txspeed_histogram_max = v +i = ii +} + +76 { +res.has_txspeed_ntile_5th = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.txspeed_ntile_5th = v +i = ii +} + +77 { +res.has_txspeed_ntile_50th = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.txspeed_ntile_50th = v +i = ii +} + +78 { +res.has_txspeed_ntile_75th = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.txspeed_ntile_75th = v +i = ii +} + +79 { +res.has_txspeed_ntile_95th = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.txspeed_ntile_95th = v +i = ii +} + +80 { +res.has_txspeed_ntile_98th = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.txspeed_ntile_98th = v +i = ii +} + +81 { +res.has_rxspeed_max = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rxspeed_max = v +i = ii +} + +82 { +res.has_rxspeed_histogram_16 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rxspeed_histogram_16 = v +i = ii +} + +83 { +res.has_rxspeed_histogram_32 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rxspeed_histogram_32 = v +i = ii +} + +84 { +res.has_rxspeed_histogram_64 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rxspeed_histogram_64 = v +i = ii +} + +85 { +res.has_rxspeed_histogram_128 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rxspeed_histogram_128 = v +i = ii +} + +86 { +res.has_rxspeed_histogram_256 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rxspeed_histogram_256 = v +i = ii +} + +87 { +res.has_rxspeed_histogram_512 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rxspeed_histogram_512 = v +i = ii +} + +88 { +res.has_rxspeed_histogram_1024 = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rxspeed_histogram_1024 = v +i = ii +} + +89 { +res.has_rxspeed_histogram_max = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rxspeed_histogram_max = v +i = ii +} + +90 { +res.has_rxspeed_ntile_5th = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rxspeed_ntile_5th = v +i = ii +} + +91 { +res.has_rxspeed_ntile_50th = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rxspeed_ntile_50th = v +i = ii +} + +92 { +res.has_rxspeed_ntile_75th = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rxspeed_ntile_75th = v +i = ii +} + +93 { +res.has_rxspeed_ntile_95th = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rxspeed_ntile_95th = v +i = ii +} + +94 { +res.has_rxspeed_ntile_98th = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.rxspeed_ntile_98th = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramlinklifetimestats() CMsgSteamDatagramLinkLifetimeStats { +return CMsgSteamDatagramLinkLifetimeStats{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramlinklifetimestats(o CMsgSteamDatagramLinkLifetimeStats, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramlinklifetimestats(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramLinkLifetimeStats) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramlinklifetimestats_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamDatagramConnectionQuality { +mut: +unknown_fields []vproto.UnknownField +pub mut: +instantaneous CMsgSteamDatagramLinkInstantaneousStats +has_instantaneous bool +lifetime CMsgSteamDatagramLinkLifetimeStats +has_lifetime bool +} +pub fn (o &CMsgSteamDatagramConnectionQuality) pack() []byte { +mut res := []byte{} +if o.has_instantaneous { +res << zzz_vproto_internal_pack_cmsgsteamdatagramlinkinstantaneousstats(o.instantaneous, 1) +} + +if o.has_lifetime { +res << zzz_vproto_internal_pack_cmsgsteamdatagramlinklifetimestats(o.lifetime, 2) +} + +return res +} + +pub fn cmsgsteamdatagramconnectionquality_unpack(buf []byte) ?CMsgSteamDatagramConnectionQuality { +mut res := CMsgSteamDatagramConnectionQuality{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_instantaneous = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramlinkinstantaneousstats(cur_buf, tag_wiretype.wire_type)? +res.instantaneous = v +i = ii +} + +2 { +res.has_lifetime = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramlinklifetimestats(cur_buf, tag_wiretype.wire_type)? +res.lifetime = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamdatagramconnectionquality() CMsgSteamDatagramConnectionQuality { +return CMsgSteamDatagramConnectionQuality{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamdatagramconnectionquality(o CMsgSteamDatagramConnectionQuality, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionquality(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamDatagramConnectionQuality) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamdatagramconnectionquality_unpack(v)? +return i, unpacked +} +pub struct CMsgICerendezvousAuth { +mut: +unknown_fields []vproto.UnknownField +pub mut: +pwd_frag string +has_pwd_frag bool +} +pub fn (o &CMsgICerendezvousAuth) pack() []byte { +mut res := []byte{} +if o.has_pwd_frag { +res << vproto.pack_string_field(o.pwd_frag, 1) +} + +return res +} + +pub fn cmsgicerendezvousauth_unpack(buf []byte) ?CMsgICerendezvousAuth { +mut res := CMsgICerendezvousAuth{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_pwd_frag = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.pwd_frag = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgicerendezvousauth() CMsgICerendezvousAuth { +return CMsgICerendezvousAuth{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgicerendezvousauth(o CMsgICerendezvousAuth, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgicerendezvousauth(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgICerendezvousAuth) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgicerendezvousauth_unpack(v)? +return i, unpacked +} +pub struct CMsgICerendezvousCandidate { +mut: +unknown_fields []vproto.UnknownField +pub mut: +candidate string +has_candidate bool +} +pub fn (o &CMsgICerendezvousCandidate) pack() []byte { +mut res := []byte{} +if o.has_candidate { +res << vproto.pack_string_field(o.candidate, 3) +} + +return res +} + +pub fn cmsgicerendezvouscandidate_unpack(buf []byte) ?CMsgICerendezvousCandidate { +mut res := CMsgICerendezvousCandidate{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +3 { +res.has_candidate = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.candidate = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgicerendezvouscandidate() CMsgICerendezvousCandidate { +return CMsgICerendezvousCandidate{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgicerendezvouscandidate(o CMsgICerendezvousCandidate, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgicerendezvouscandidate(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgICerendezvousCandidate) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgicerendezvouscandidate_unpack(v)? +return i, unpacked +} +pub struct CMsgICerendezvous { +mut: +unknown_fields []vproto.UnknownField +pub mut: +auth CMsgICerendezvousAuth +has_auth bool +add_candidate CMsgICerendezvousCandidate +has_add_candidate bool +} +pub fn (o &CMsgICerendezvous) pack() []byte { +mut res := []byte{} +if o.has_auth { +res << zzz_vproto_internal_pack_cmsgicerendezvousauth(o.auth, 2) +} + +if o.has_add_candidate { +res << zzz_vproto_internal_pack_cmsgicerendezvouscandidate(o.add_candidate, 1) +} + +return res +} + +pub fn cmsgicerendezvous_unpack(buf []byte) ?CMsgICerendezvous { +mut res := CMsgICerendezvous{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +2 { +res.has_auth = true +ii, v := zzz_vproto_internal_unpack_cmsgicerendezvousauth(cur_buf, tag_wiretype.wire_type)? +res.auth = v +i = ii +} + +1 { +res.has_add_candidate = true +ii, v := zzz_vproto_internal_unpack_cmsgicerendezvouscandidate(cur_buf, tag_wiretype.wire_type)? +res.add_candidate = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgicerendezvous() CMsgICerendezvous { +return CMsgICerendezvous{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgicerendezvous(o CMsgICerendezvous, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgicerendezvous(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgICerendezvous) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgicerendezvous_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamNetworkingP2PRendezvousConnectRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +crypt CMsgSteamDatagramSessionCryptInfoSigned +has_crypt bool +cert CMsgSteamDatagramCertificateSigned +has_cert bool +virtual_port u32 +has_virtual_port bool +} +pub fn (o &CMsgSteamNetworkingP2PRendezvousConnectRequest) pack() []byte { +mut res := []byte{} +if o.has_crypt { +res << zzz_vproto_internal_pack_cmsgsteamdatagramsessioncryptinfosigned(o.crypt, 6) +} + +if o.has_cert { +res << zzz_vproto_internal_pack_cmsgsteamdatagramcertificatesigned(o.cert, 7) +} + +if o.has_virtual_port { +res << vproto.pack_uint32_field(o.virtual_port, 9) +} + +return res +} + +pub fn cmsgsteamnetworkingp2prendezvousconnectrequest_unpack(buf []byte) ?CMsgSteamNetworkingP2PRendezvousConnectRequest { +mut res := CMsgSteamNetworkingP2PRendezvousConnectRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +6 { +res.has_crypt = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramsessioncryptinfosigned(cur_buf, tag_wiretype.wire_type)? +res.crypt = v +i = ii +} + +7 { +res.has_cert = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramcertificatesigned(cur_buf, tag_wiretype.wire_type)? +res.cert = v +i = ii +} + +9 { +res.has_virtual_port = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.virtual_port = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamnetworkingp2prendezvousconnectrequest() CMsgSteamNetworkingP2PRendezvousConnectRequest { +return CMsgSteamNetworkingP2PRendezvousConnectRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamnetworkingp2prendezvousconnectrequest(o CMsgSteamNetworkingP2PRendezvousConnectRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamnetworkingp2prendezvousconnectrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamNetworkingP2PRendezvousConnectRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamnetworkingp2prendezvousconnectrequest_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamNetworkingP2PRendezvousConnectOK { +mut: +unknown_fields []vproto.UnknownField +pub mut: +crypt CMsgSteamDatagramSessionCryptInfoSigned +has_crypt bool +cert CMsgSteamDatagramCertificateSigned +has_cert bool +} +pub fn (o &CMsgSteamNetworkingP2PRendezvousConnectOK) pack() []byte { +mut res := []byte{} +if o.has_crypt { +res << zzz_vproto_internal_pack_cmsgsteamdatagramsessioncryptinfosigned(o.crypt, 5) +} + +if o.has_cert { +res << zzz_vproto_internal_pack_cmsgsteamdatagramcertificatesigned(o.cert, 6) +} + +return res +} + +pub fn cmsgsteamnetworkingp2prendezvousconnectok_unpack(buf []byte) ?CMsgSteamNetworkingP2PRendezvousConnectOK { +mut res := CMsgSteamNetworkingP2PRendezvousConnectOK{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +5 { +res.has_crypt = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramsessioncryptinfosigned(cur_buf, tag_wiretype.wire_type)? +res.crypt = v +i = ii +} + +6 { +res.has_cert = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramcertificatesigned(cur_buf, tag_wiretype.wire_type)? +res.cert = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamnetworkingp2prendezvousconnectok() CMsgSteamNetworkingP2PRendezvousConnectOK { +return CMsgSteamNetworkingP2PRendezvousConnectOK{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamnetworkingp2prendezvousconnectok(o CMsgSteamNetworkingP2PRendezvousConnectOK, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamnetworkingp2prendezvousconnectok(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamNetworkingP2PRendezvousConnectOK) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamnetworkingp2prendezvousconnectok_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamNetworkingP2PRendezvousConnectionClosed { +mut: +unknown_fields []vproto.UnknownField +pub mut: +debug string +has_debug bool +reason_code u32 +has_reason_code bool +} +pub fn (o &CMsgSteamNetworkingP2PRendezvousConnectionClosed) pack() []byte { +mut res := []byte{} +if o.has_debug { +res << vproto.pack_string_field(o.debug, 5) +} + +if o.has_reason_code { +res << vproto.pack_uint32_field(o.reason_code, 6) +} + +return res +} + +pub fn cmsgsteamnetworkingp2prendezvousconnectionclosed_unpack(buf []byte) ?CMsgSteamNetworkingP2PRendezvousConnectionClosed { +mut res := CMsgSteamNetworkingP2PRendezvousConnectionClosed{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +5 { +res.has_debug = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.debug = v +i = ii +} + +6 { +res.has_reason_code = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.reason_code = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamnetworkingp2prendezvousconnectionclosed() CMsgSteamNetworkingP2PRendezvousConnectionClosed { +return CMsgSteamNetworkingP2PRendezvousConnectionClosed{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamnetworkingp2prendezvousconnectionclosed(o CMsgSteamNetworkingP2PRendezvousConnectionClosed, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamnetworkingp2prendezvousconnectionclosed(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamNetworkingP2PRendezvousConnectionClosed) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamnetworkingp2prendezvousconnectionclosed_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamNetworkingP2PRendezvousReliableMessage { +mut: +unknown_fields []vproto.UnknownField +pub mut: +ice CMsgICerendezvous +has_ice bool +} +pub fn (o &CMsgSteamNetworkingP2PRendezvousReliableMessage) pack() []byte { +mut res := []byte{} +if o.has_ice { +res << zzz_vproto_internal_pack_cmsgicerendezvous(o.ice, 1) +} + +return res +} + +pub fn cmsgsteamnetworkingp2prendezvousreliablemessage_unpack(buf []byte) ?CMsgSteamNetworkingP2PRendezvousReliableMessage { +mut res := CMsgSteamNetworkingP2PRendezvousReliableMessage{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_ice = true +ii, v := zzz_vproto_internal_unpack_cmsgicerendezvous(cur_buf, tag_wiretype.wire_type)? +res.ice = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamnetworkingp2prendezvousreliablemessage() CMsgSteamNetworkingP2PRendezvousReliableMessage { +return CMsgSteamNetworkingP2PRendezvousReliableMessage{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamnetworkingp2prendezvousreliablemessage(o CMsgSteamNetworkingP2PRendezvousReliableMessage, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamnetworkingp2prendezvousreliablemessage(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamNetworkingP2PRendezvousReliableMessage) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamnetworkingp2prendezvousreliablemessage_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamNetworkingP2PRendezvous { +mut: +unknown_fields []vproto.UnknownField +pub mut: +from_identity string +has_from_identity bool +from_connection_id u32 +has_from_connection_id bool +to_identity string +has_to_identity bool +to_connection_id u32 +has_to_connection_id bool +sdr_routes []byte +has_sdr_routes bool +ack_peer_routes_revision u32 +has_ack_peer_routes_revision bool +ice_enabled bool +has_ice_enabled bool +connect_request CMsgSteamNetworkingP2PRendezvousConnectRequest +has_connect_request bool +connect_ok CMsgSteamNetworkingP2PRendezvousConnectOK +has_connect_ok bool +connection_closed CMsgSteamNetworkingP2PRendezvousConnectionClosed +has_connection_closed bool +ack_reliable_msg u32 +has_ack_reliable_msg bool +first_reliable_msg u32 +has_first_reliable_msg bool +reliable_messages []CMsgSteamNetworkingP2PRendezvousReliableMessage +} +pub fn (o &CMsgSteamNetworkingP2PRendezvous) pack() []byte { +mut res := []byte{} +if o.has_from_identity { +res << vproto.pack_string_field(o.from_identity, 8) +} + +if o.has_from_connection_id { +res << vproto.pack_32bit_field(o.from_connection_id, 9) +} + +if o.has_to_identity { +res << vproto.pack_string_field(o.to_identity, 10) +} + +if o.has_to_connection_id { +res << vproto.pack_32bit_field(o.to_connection_id, 1) +} + +if o.has_sdr_routes { +res << vproto.pack_bytes_field(o.sdr_routes, 2) +} + +if o.has_ack_peer_routes_revision { +res << vproto.pack_uint32_field(o.ack_peer_routes_revision, 3) +} + +if o.has_ice_enabled { +res << vproto.pack_bool_field(o.ice_enabled, 7) +} + +if o.has_connect_request { +res << zzz_vproto_internal_pack_cmsgsteamnetworkingp2prendezvousconnectrequest(o.connect_request, 4) +} + +if o.has_connect_ok { +res << zzz_vproto_internal_pack_cmsgsteamnetworkingp2prendezvousconnectok(o.connect_ok, 5) +} + +if o.has_connection_closed { +res << zzz_vproto_internal_pack_cmsgsteamnetworkingp2prendezvousconnectionclosed(o.connection_closed, 6) +} + +if o.has_ack_reliable_msg { +res << vproto.pack_uint32_field(o.ack_reliable_msg, 11) +} + +if o.has_first_reliable_msg { +res << vproto.pack_uint32_field(o.first_reliable_msg, 12) +} + +// [packed=false] +for _, x in o.reliable_messages { +res << zzz_vproto_internal_pack_cmsgsteamnetworkingp2prendezvousreliablemessage(x, 13) +} + +return res +} + +pub fn cmsgsteamnetworkingp2prendezvous_unpack(buf []byte) ?CMsgSteamNetworkingP2PRendezvous { +mut res := CMsgSteamNetworkingP2PRendezvous{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +8 { +res.has_from_identity = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.from_identity = v +i = ii +} + +9 { +res.has_from_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.from_connection_id = v +i = ii +} + +10 { +res.has_to_identity = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.to_identity = v +i = ii +} + +1 { +res.has_to_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.to_connection_id = v +i = ii +} + +2 { +res.has_sdr_routes = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sdr_routes = v +i = ii +} + +3 { +res.has_ack_peer_routes_revision = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ack_peer_routes_revision = v +i = ii +} + +7 { +res.has_ice_enabled = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.ice_enabled = v +i = ii +} + +4 { +res.has_connect_request = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamnetworkingp2prendezvousconnectrequest(cur_buf, tag_wiretype.wire_type)? +res.connect_request = v +i = ii +} + +5 { +res.has_connect_ok = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamnetworkingp2prendezvousconnectok(cur_buf, tag_wiretype.wire_type)? +res.connect_ok = v +i = ii +} + +6 { +res.has_connection_closed = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamnetworkingp2prendezvousconnectionclosed(cur_buf, tag_wiretype.wire_type)? +res.connection_closed = v +i = ii +} + +11 { +res.has_ack_reliable_msg = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ack_reliable_msg = v +i = ii +} + +12 { +res.has_first_reliable_msg = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.first_reliable_msg = v +i = ii +} + +13 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cmsgsteamnetworkingp2prendezvousreliablemessage(cur_buf, tag_wiretype.wire_type)? +res.reliable_messages << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamnetworkingp2prendezvous() CMsgSteamNetworkingP2PRendezvous { +return CMsgSteamNetworkingP2PRendezvous{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamnetworkingp2prendezvous(o CMsgSteamNetworkingP2PRendezvous, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamnetworkingp2prendezvous(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamNetworkingP2PRendezvous) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamnetworkingp2prendezvous_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamNetworkingICesessionSummary { +mut: +unknown_fields []vproto.UnknownField +pub mut: +failure_reason_code u32 +has_failure_reason_code bool +local_candidate_types u32 +has_local_candidate_types bool +remote_candidate_types u32 +has_remote_candidate_types bool +initial_route_kind u32 +has_initial_route_kind bool +initial_ping u32 +has_initial_ping bool +initial_score u32 +has_initial_score bool +negotiation_ms u32 +has_negotiation_ms bool +selected_seconds u32 +has_selected_seconds bool +} +pub fn (o &CMsgSteamNetworkingICesessionSummary) pack() []byte { +mut res := []byte{} +if o.has_failure_reason_code { +res << vproto.pack_uint32_field(o.failure_reason_code, 7) +} + +if o.has_local_candidate_types { +res << vproto.pack_uint32_field(o.local_candidate_types, 1) +} + +if o.has_remote_candidate_types { +res << vproto.pack_uint32_field(o.remote_candidate_types, 2) +} + +if o.has_initial_route_kind { +res << vproto.pack_uint32_field(o.initial_route_kind, 3) +} + +if o.has_initial_ping { +res << vproto.pack_uint32_field(o.initial_ping, 4) +} + +if o.has_initial_score { +res << vproto.pack_uint32_field(o.initial_score, 6) +} + +if o.has_negotiation_ms { +res << vproto.pack_uint32_field(o.negotiation_ms, 5) +} + +if o.has_selected_seconds { +res << vproto.pack_uint32_field(o.selected_seconds, 12) +} + +return res +} + +pub fn cmsgsteamnetworkingicesessionsummary_unpack(buf []byte) ?CMsgSteamNetworkingICesessionSummary { +mut res := CMsgSteamNetworkingICesessionSummary{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +7 { +res.has_failure_reason_code = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.failure_reason_code = v +i = ii +} + +1 { +res.has_local_candidate_types = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.local_candidate_types = v +i = ii +} + +2 { +res.has_remote_candidate_types = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.remote_candidate_types = v +i = ii +} + +3 { +res.has_initial_route_kind = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.initial_route_kind = v +i = ii +} + +4 { +res.has_initial_ping = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.initial_ping = v +i = ii +} + +6 { +res.has_initial_score = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.initial_score = v +i = ii +} + +5 { +res.has_negotiation_ms = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.negotiation_ms = v +i = ii +} + +12 { +res.has_selected_seconds = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.selected_seconds = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamnetworkingicesessionsummary() CMsgSteamNetworkingICesessionSummary { +return CMsgSteamNetworkingICesessionSummary{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamnetworkingicesessionsummary(o CMsgSteamNetworkingICesessionSummary, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamnetworkingicesessionsummary(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamNetworkingICesessionSummary) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamnetworkingicesessionsummary_unpack(v)? +return i, unpacked +} diff --git a/proto/steamnetworkingsockets_messages_udp_pb.v b/proto/steamnetworkingsockets_messages_udp_pb.v new file mode 100644 index 0000000..825b766 --- /dev/null +++ b/proto/steamnetworkingsockets_messages_udp_pb.v @@ -0,0 +1,797 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +[_allow_multiple_values] +enum ESteamNetworkingUDpmsgID { +k_esteamnetworkingudpmsg_challengerequest = 32 +k_esteamnetworkingudpmsg_challengereply = 33 +k_esteamnetworkingudpmsg_connectrequest = 34 +k_esteamnetworkingudpmsg_connectok = 35 +k_esteamnetworkingudpmsg_connectionclosed = 36 +k_esteamnetworkingudpmsg_noconnection = 37 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_esteamnetworkingudpmsgid(e ESteamNetworkingUDpmsgID, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_esteamnetworkingudpmsgid(buf []byte, tag_wiretype vproto.WireType) ?(int, ESteamNetworkingUDpmsgID) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, ESteamNetworkingUDpmsgID(v) +} +pub struct CMsgSteamSocketsUDpchallengeRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +connection_id u32 +has_connection_id bool +my_timestamp u64 +has_my_timestamp bool +protocol_version u32 +has_protocol_version bool +} +pub fn (o &CMsgSteamSocketsUDpchallengeRequest) pack() []byte { +mut res := []byte{} +if o.has_connection_id { +res << vproto.pack_32bit_field(o.connection_id, 1) +} + +if o.has_my_timestamp { +res << vproto.pack_64bit_field(o.my_timestamp, 3) +} + +if o.has_protocol_version { +res << vproto.pack_uint32_field(o.protocol_version, 4) +} + +return res +} + +pub fn cmsgsteamsocketsudpchallengerequest_unpack(buf []byte) ?CMsgSteamSocketsUDpchallengeRequest { +mut res := CMsgSteamSocketsUDpchallengeRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.connection_id = v +i = ii +} + +3 { +res.has_my_timestamp = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.my_timestamp = v +i = ii +} + +4 { +res.has_protocol_version = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.protocol_version = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamsocketsudpchallengerequest() CMsgSteamSocketsUDpchallengeRequest { +return CMsgSteamSocketsUDpchallengeRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamsocketsudpchallengerequest(o CMsgSteamSocketsUDpchallengeRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamsocketsudpchallengerequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamSocketsUDpchallengeRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamsocketsudpchallengerequest_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamSocketsUDpchallengeReply { +mut: +unknown_fields []vproto.UnknownField +pub mut: +connection_id u32 +has_connection_id bool +challenge u64 +has_challenge bool +your_timestamp u64 +has_your_timestamp bool +protocol_version u32 +has_protocol_version bool +} +pub fn (o &CMsgSteamSocketsUDpchallengeReply) pack() []byte { +mut res := []byte{} +if o.has_connection_id { +res << vproto.pack_32bit_field(o.connection_id, 1) +} + +if o.has_challenge { +res << vproto.pack_64bit_field(o.challenge, 2) +} + +if o.has_your_timestamp { +res << vproto.pack_64bit_field(o.your_timestamp, 3) +} + +if o.has_protocol_version { +res << vproto.pack_uint32_field(o.protocol_version, 4) +} + +return res +} + +pub fn cmsgsteamsocketsudpchallengereply_unpack(buf []byte) ?CMsgSteamSocketsUDpchallengeReply { +mut res := CMsgSteamSocketsUDpchallengeReply{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.connection_id = v +i = ii +} + +2 { +res.has_challenge = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.challenge = v +i = ii +} + +3 { +res.has_your_timestamp = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.your_timestamp = v +i = ii +} + +4 { +res.has_protocol_version = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.protocol_version = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamsocketsudpchallengereply() CMsgSteamSocketsUDpchallengeReply { +return CMsgSteamSocketsUDpchallengeReply{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamsocketsudpchallengereply(o CMsgSteamSocketsUDpchallengeReply, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamsocketsudpchallengereply(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamSocketsUDpchallengeReply) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamsocketsudpchallengereply_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamSocketsUDpconnectRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +client_connection_id u32 +has_client_connection_id bool +challenge u64 +has_challenge bool +my_timestamp u64 +has_my_timestamp bool +ping_est_ms u32 +has_ping_est_ms bool +crypt CMsgSteamDatagramSessionCryptInfoSigned +has_crypt bool +cert CMsgSteamDatagramCertificateSigned +has_cert bool +legacy_protocol_version u32 +has_legacy_protocol_version bool +identity_string string +has_identity_string bool +legacy_client_steam_id u64 +has_legacy_client_steam_id bool +legacy_identity_binary CMsgSteamNetworkingIdentityLegacyBinary +has_legacy_identity_binary bool +} +pub fn (o &CMsgSteamSocketsUDpconnectRequest) pack() []byte { +mut res := []byte{} +if o.has_client_connection_id { +res << vproto.pack_32bit_field(o.client_connection_id, 1) +} + +if o.has_challenge { +res << vproto.pack_64bit_field(o.challenge, 2) +} + +if o.has_my_timestamp { +res << vproto.pack_64bit_field(o.my_timestamp, 5) +} + +if o.has_ping_est_ms { +res << vproto.pack_uint32_field(o.ping_est_ms, 6) +} + +if o.has_crypt { +res << zzz_vproto_internal_pack_cmsgsteamdatagramsessioncryptinfosigned(o.crypt, 7) +} + +if o.has_cert { +res << zzz_vproto_internal_pack_cmsgsteamdatagramcertificatesigned(o.cert, 4) +} + +if o.has_legacy_protocol_version { +res << vproto.pack_uint32_field(o.legacy_protocol_version, 8) +} + +if o.has_identity_string { +res << vproto.pack_string_field(o.identity_string, 10) +} + +if o.has_legacy_client_steam_id { +res << vproto.pack_64bit_field(o.legacy_client_steam_id, 3) +} + +if o.has_legacy_identity_binary { +res << zzz_vproto_internal_pack_cmsgsteamnetworkingidentitylegacybinary(o.legacy_identity_binary, 9) +} + +return res +} + +pub fn cmsgsteamsocketsudpconnectrequest_unpack(buf []byte) ?CMsgSteamSocketsUDpconnectRequest { +mut res := CMsgSteamSocketsUDpconnectRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_client_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.client_connection_id = v +i = ii +} + +2 { +res.has_challenge = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.challenge = v +i = ii +} + +5 { +res.has_my_timestamp = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.my_timestamp = v +i = ii +} + +6 { +res.has_ping_est_ms = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.ping_est_ms = v +i = ii +} + +7 { +res.has_crypt = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramsessioncryptinfosigned(cur_buf, tag_wiretype.wire_type)? +res.crypt = v +i = ii +} + +4 { +res.has_cert = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramcertificatesigned(cur_buf, tag_wiretype.wire_type)? +res.cert = v +i = ii +} + +8 { +res.has_legacy_protocol_version = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.legacy_protocol_version = v +i = ii +} + +10 { +res.has_identity_string = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.identity_string = v +i = ii +} + +3 { +res.has_legacy_client_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.legacy_client_steam_id = v +i = ii +} + +9 { +res.has_legacy_identity_binary = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamnetworkingidentitylegacybinary(cur_buf, tag_wiretype.wire_type)? +res.legacy_identity_binary = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamsocketsudpconnectrequest() CMsgSteamSocketsUDpconnectRequest { +return CMsgSteamSocketsUDpconnectRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamsocketsudpconnectrequest(o CMsgSteamSocketsUDpconnectRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamsocketsudpconnectrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamSocketsUDpconnectRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamsocketsudpconnectrequest_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamSocketsUDpconnectOK { +mut: +unknown_fields []vproto.UnknownField +pub mut: +client_connection_id u32 +has_client_connection_id bool +server_connection_id u32 +has_server_connection_id bool +your_timestamp u64 +has_your_timestamp bool +delay_time_usec u32 +has_delay_time_usec bool +crypt CMsgSteamDatagramSessionCryptInfoSigned +has_crypt bool +cert CMsgSteamDatagramCertificateSigned +has_cert bool +identity_string string +has_identity_string bool +legacy_server_steam_id u64 +has_legacy_server_steam_id bool +legacy_identity_binary CMsgSteamNetworkingIdentityLegacyBinary +has_legacy_identity_binary bool +} +pub fn (o &CMsgSteamSocketsUDpconnectOK) pack() []byte { +mut res := []byte{} +if o.has_client_connection_id { +res << vproto.pack_32bit_field(o.client_connection_id, 1) +} + +if o.has_server_connection_id { +res << vproto.pack_32bit_field(o.server_connection_id, 5) +} + +if o.has_your_timestamp { +res << vproto.pack_64bit_field(o.your_timestamp, 3) +} + +if o.has_delay_time_usec { +res << vproto.pack_uint32_field(o.delay_time_usec, 4) +} + +if o.has_crypt { +res << zzz_vproto_internal_pack_cmsgsteamdatagramsessioncryptinfosigned(o.crypt, 7) +} + +if o.has_cert { +res << zzz_vproto_internal_pack_cmsgsteamdatagramcertificatesigned(o.cert, 8) +} + +if o.has_identity_string { +res << vproto.pack_string_field(o.identity_string, 11) +} + +if o.has_legacy_server_steam_id { +res << vproto.pack_64bit_field(o.legacy_server_steam_id, 2) +} + +if o.has_legacy_identity_binary { +res << zzz_vproto_internal_pack_cmsgsteamnetworkingidentitylegacybinary(o.legacy_identity_binary, 10) +} + +return res +} + +pub fn cmsgsteamsocketsudpconnectok_unpack(buf []byte) ?CMsgSteamSocketsUDpconnectOK { +mut res := CMsgSteamSocketsUDpconnectOK{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_client_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.client_connection_id = v +i = ii +} + +5 { +res.has_server_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.server_connection_id = v +i = ii +} + +3 { +res.has_your_timestamp = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.your_timestamp = v +i = ii +} + +4 { +res.has_delay_time_usec = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.delay_time_usec = v +i = ii +} + +7 { +res.has_crypt = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramsessioncryptinfosigned(cur_buf, tag_wiretype.wire_type)? +res.crypt = v +i = ii +} + +8 { +res.has_cert = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramcertificatesigned(cur_buf, tag_wiretype.wire_type)? +res.cert = v +i = ii +} + +11 { +res.has_identity_string = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.identity_string = v +i = ii +} + +2 { +res.has_legacy_server_steam_id = true +ii, v := vproto.unpack_64bit_field(cur_buf, tag_wiretype.wire_type)? +res.legacy_server_steam_id = v +i = ii +} + +10 { +res.has_legacy_identity_binary = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamnetworkingidentitylegacybinary(cur_buf, tag_wiretype.wire_type)? +res.legacy_identity_binary = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamsocketsudpconnectok() CMsgSteamSocketsUDpconnectOK { +return CMsgSteamSocketsUDpconnectOK{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamsocketsudpconnectok(o CMsgSteamSocketsUDpconnectOK, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamsocketsudpconnectok(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamSocketsUDpconnectOK) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamsocketsudpconnectok_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamSocketsUDpconnectionClosed { +mut: +unknown_fields []vproto.UnknownField +pub mut: +to_connection_id u32 +has_to_connection_id bool +from_connection_id u32 +has_from_connection_id bool +debug string +has_debug bool +reason_code u32 +has_reason_code bool +} +pub fn (o &CMsgSteamSocketsUDpconnectionClosed) pack() []byte { +mut res := []byte{} +if o.has_to_connection_id { +res << vproto.pack_32bit_field(o.to_connection_id, 4) +} + +if o.has_from_connection_id { +res << vproto.pack_32bit_field(o.from_connection_id, 5) +} + +if o.has_debug { +res << vproto.pack_string_field(o.debug, 2) +} + +if o.has_reason_code { +res << vproto.pack_uint32_field(o.reason_code, 3) +} + +return res +} + +pub fn cmsgsteamsocketsudpconnectionclosed_unpack(buf []byte) ?CMsgSteamSocketsUDpconnectionClosed { +mut res := CMsgSteamSocketsUDpconnectionClosed{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +4 { +res.has_to_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.to_connection_id = v +i = ii +} + +5 { +res.has_from_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.from_connection_id = v +i = ii +} + +2 { +res.has_debug = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.debug = v +i = ii +} + +3 { +res.has_reason_code = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.reason_code = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamsocketsudpconnectionclosed() CMsgSteamSocketsUDpconnectionClosed { +return CMsgSteamSocketsUDpconnectionClosed{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamsocketsudpconnectionclosed(o CMsgSteamSocketsUDpconnectionClosed, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamsocketsudpconnectionclosed(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamSocketsUDpconnectionClosed) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamsocketsudpconnectionclosed_unpack(v)? +return i, unpacked +} +pub struct CMsgSteamSocketsUDpnoConnection { +mut: +unknown_fields []vproto.UnknownField +pub mut: +from_connection_id u32 +has_from_connection_id bool +to_connection_id u32 +has_to_connection_id bool +} +pub fn (o &CMsgSteamSocketsUDpnoConnection) pack() []byte { +mut res := []byte{} +if o.has_from_connection_id { +res << vproto.pack_32bit_field(o.from_connection_id, 2) +} + +if o.has_to_connection_id { +res << vproto.pack_32bit_field(o.to_connection_id, 3) +} + +return res +} + +pub fn cmsgsteamsocketsudpnoconnection_unpack(buf []byte) ?CMsgSteamSocketsUDpnoConnection { +mut res := CMsgSteamSocketsUDpnoConnection{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +2 { +res.has_from_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.from_connection_id = v +i = ii +} + +3 { +res.has_to_connection_id = true +ii, v := vproto.unpack_32bit_field(cur_buf, tag_wiretype.wire_type)? +res.to_connection_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamsocketsudpnoconnection() CMsgSteamSocketsUDpnoConnection { +return CMsgSteamSocketsUDpnoConnection{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamsocketsudpnoconnection(o CMsgSteamSocketsUDpnoConnection, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamsocketsudpnoconnection(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamSocketsUDpnoConnection) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamsocketsudpnoconnection_unpack(v)? +return i, unpacked +} +[_allow_multiple_values] +enum CMsgSteamSocketsUDpstatsFlags { +ack_request_e2e = 2 +ack_request_immediate = 4 +not_primary_transport_e2e = 16 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_cmsgsteamsocketsudpstatsflags(e CMsgSteamSocketsUDpstatsFlags, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_cmsgsteamsocketsudpstatsflags(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamSocketsUDpstatsFlags) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, CMsgSteamSocketsUDpstatsFlags(v) +} +pub struct CMsgSteamSocketsUDpstats { +mut: +unknown_fields []vproto.UnknownField +pub mut: +stats CMsgSteamDatagramConnectionQuality +has_stats bool +flags u32 +has_flags bool +} +pub fn (o &CMsgSteamSocketsUDpstats) pack() []byte { +mut res := []byte{} +if o.has_stats { +res << zzz_vproto_internal_pack_cmsgsteamdatagramconnectionquality(o.stats, 1) +} + +if o.has_flags { +res << vproto.pack_uint32_field(o.flags, 3) +} + +return res +} + +pub fn cmsgsteamsocketsudpstats_unpack(buf []byte) ?CMsgSteamSocketsUDpstats { +mut res := CMsgSteamSocketsUDpstats{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_stats = true +ii, v := zzz_vproto_internal_unpack_cmsgsteamdatagramconnectionquality(cur_buf, tag_wiretype.wire_type)? +res.stats = v +i = ii +} + +3 { +res.has_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.flags = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cmsgsteamsocketsudpstats() CMsgSteamSocketsUDpstats { +return CMsgSteamSocketsUDpstats{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cmsgsteamsocketsudpstats(o CMsgSteamSocketsUDpstats, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cmsgsteamsocketsudpstats(buf []byte, tag_wiretype vproto.WireType) ?(int, CMsgSteamSocketsUDpstats) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cmsgsteamsocketsudpstats_unpack(v)? +return i, unpacked +} diff --git a/proto/stream_pb.v b/proto/stream_pb.v new file mode 100644 index 0000000..a21d1ab --- /dev/null +++ b/proto/stream_pb.v @@ -0,0 +1,7401 @@ + +// Generated by vproto - Do not modify +module proto + +import emily33901.vproto + + +[_allow_multiple_values] +enum EStreamChannel { +k_estreamchannelinvalid = -1 +k_estreamchanneldiscovery = 0 +k_estreamchannelcontrol = 1 +k_estreamchannelstats = 2 +k_estreamchanneldatachannelstart = 3 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_estreamchannel(e EStreamChannel, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_estreamchannel(buf []byte, tag_wiretype vproto.WireType) ?(int, EStreamChannel) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EStreamChannel(v) +} +[_allow_multiple_values] +enum EStreamDiscoveryMessage { +k_estreamdiscoverypingrequest = 1 +k_estreamdiscoverypingresponse = 2 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_estreamdiscoverymessage(e EStreamDiscoveryMessage, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_estreamdiscoverymessage(buf []byte, tag_wiretype vproto.WireType) ?(int, EStreamDiscoveryMessage) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EStreamDiscoveryMessage(v) +} +[_allow_multiple_values] +enum EStreamControlMessage { +k_estreamcontrolauthenticationrequest = 1 +k_estreamcontrolauthenticationresponse = 2 +k_estreamcontrolnegotiationinit = 3 +k_estreamcontrolnegotiationsetconfig = 4 +k_estreamcontrolnegotiationcomplete = 5 +k_estreamcontrolclienthandshake = 6 +k_estreamcontrolserverhandshake = 7 +k_estreamcontrolstartnetworktest = 8 +k_estreamcontrolkeepalive = 9 +k_estreamcontrol_last_setup_message = 15 +k_estreamcontrolstartaudiodata = 50 +k_estreamcontrolstopaudiodata = 51 +k_estreamcontrolstartvideodata = 52 +k_estreamcontrolstopvideodata = 53 +k_estreamcontrolinputmousemotion = 54 +k_estreamcontrolinputmousewheel = 55 +k_estreamcontrolinputmousedown = 56 +k_estreamcontrolinputmouseup = 57 +k_estreamcontrolinputkeydown = 58 +k_estreamcontrolinputkeyup = 59 +k_estreamcontrolinputgamepadattached_obsolete = 60 +k_estreamcontrolinputgamepadevent_obsolete = 61 +k_estreamcontrolinputgamepaddetached_obsolete = 62 +k_estreamcontrolshowcursor = 63 +k_estreamcontrolhidecursor = 64 +k_estreamcontrolsetcursor = 65 +k_estreamcontrolgetcursorimage = 66 +k_estreamcontrolsetcursorimage = 67 +k_estreamcontroldeletecursor = 68 +k_estreamcontrolsettargetframerate = 69 +k_estreamcontrolinputlatencytest = 70 +k_estreamcontrolgamepadrumble_obsolete = 71 +k_estreamcontroloverlayenabled = 74 +k_estreamcontrolinputcontrollerattached_obsolete = 75 +k_estreamcontrolinputcontrollerstate_obsolete = 76 +k_estreamcontroltriggerhapticpulse_obsolete = 77 +k_estreamcontrolinputcontrollerdetached_obsolete = 78 +k_estreamcontrolvideodecoderinfo = 80 +k_estreamcontrolsettitle = 81 +k_estreamcontrolseticon = 82 +k_estreamcontrolquitrequest = 83 +k_estreamcontrolsetqos = 87 +k_estreamcontrolinputcontrollerwirelesspresence_obsolete = 88 +k_estreamcontrolsetgammaramp = 89 +k_estreamcontrolvideoencoderinfo = 90 +k_estreamcontrolinputcontrollerstatehid_obsolete = 93 +k_estreamcontrolsettargetbitrate = 94 +k_estreamcontrolsetcontrollerpairingenabled_obsolete = 95 +k_estreamcontrolsetcontrollerpairingresult_obsolete = 96 +k_estreamcontroltriggercontrollerdisconnect_obsolete = 97 +k_estreamcontrolsetactivity = 98 +k_estreamcontrolsetstreamingclientconfig = 99 +k_estreamcontrolsystemsuspend = 100 +k_estreamcontrolsetcontrollersettings_obsolete = 101 +k_estreamcontrolvirtualhererequest = 102 +k_estreamcontrolvirtualhereready = 103 +k_estreamcontrolvirtualheresharedevice = 104 +k_estreamcontrolsetspectatormode = 105 +k_estreamcontrolremotehid = 106 +k_estreamcontrolstartmicrophonedata = 107 +k_estreamcontrolstopmicrophonedata = 108 +k_estreamcontrolinputtext = 109 +k_estreamcontroltouchconfigactive = 110 +k_estreamcontrolgettouchconfigdata = 111 +k_estreamcontrolsettouchconfigdata = 112 +k_estreamcontrolsavetouchconfiglayout = 113 +k_estreamcontroltouchactionsetactive = 114 +k_estreamcontrolgettouchicondata = 115 +k_estreamcontrolsettouchicondata = 116 +k_estreamcontrolinputtouchfingerdown = 117 +k_estreamcontrolinputtouchfingermotion = 118 +k_estreamcontrolinputtouchfingerup = 119 +k_estreamcontrolsetcapturesize = 120 +k_estreamcontrolsetflashstate = 121 +k_estreamcontrolpause = 122 +k_estreamcontrolresume = 123 +k_estreamcontrolenablehighrescapture = 124 +k_estreamcontroldisablehighrescapture = 125 +k_estreamcontroltogglemagnification = 126 +k_estreamcontrolsetcapslock = 127 +k_estreamcontrolsetkeymap = 128 +k_estreamcontrolstoprequest = 129 +k_estreamcontroltouchactionsetlayeradded = 130 +k_estreamcontroltouchactionsetlayerremoved = 131 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_estreamcontrolmessage(e EStreamControlMessage, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_estreamcontrolmessage(buf []byte, tag_wiretype vproto.WireType) ?(int, EStreamControlMessage) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EStreamControlMessage(v) +} +[_allow_multiple_values] +enum EStreamVersion { +k_estreamversionnone = 0 +k_estreamversioncurrent = 1 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_estreamversion(e EStreamVersion, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_estreamversion(buf []byte, tag_wiretype vproto.WireType) ?(int, EStreamVersion) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EStreamVersion(v) +} +[_allow_multiple_values] +enum EStreamAudioCodec { +k_estreamaudiocodecnone = 0 +k_estreamaudiocodecraw = 1 +k_estreamaudiocodecvorbis = 2 +k_estreamaudiocodecopus = 3 +k_estreamaudiocodecmp3 = 4 +k_estreamaudiocodecaac = 5 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_estreamaudiocodec(e EStreamAudioCodec, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_estreamaudiocodec(buf []byte, tag_wiretype vproto.WireType) ?(int, EStreamAudioCodec) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EStreamAudioCodec(v) +} +[_allow_multiple_values] +enum EStreamVideoCodec { +k_estreamvideocodecnone = 0 +k_estreamvideocodecraw = 1 +k_estreamvideocodecvp8 = 2 +k_estreamvideocodecvp9 = 3 +k_estreamvideocodech264 = 4 +k_estreamvideocodechevc = 5 +k_estreamvideocodecorbx1 = 6 +k_estreamvideocodecorbx2 = 7 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_estreamvideocodec(e EStreamVideoCodec, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_estreamvideocodec(buf []byte, tag_wiretype vproto.WireType) ?(int, EStreamVideoCodec) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EStreamVideoCodec(v) +} +[_allow_multiple_values] +enum EStreamQualityPreference { +k_estreamqualityfast = 1 +k_estreamqualitybalanced = 2 +k_estreamqualitybeautiful = 3 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_estreamqualitypreference(e EStreamQualityPreference, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_estreamqualitypreference(buf []byte, tag_wiretype vproto.WireType) ?(int, EStreamQualityPreference) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EStreamQualityPreference(v) +} +[_allow_multiple_values] +enum EStreamBitrate { +k_estreambitrateautodetect = -1 +k_estreambitrateunlimited = 0 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_estreambitrate(e EStreamBitrate, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_estreambitrate(buf []byte, tag_wiretype vproto.WireType) ?(int, EStreamBitrate) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EStreamBitrate(v) +} +[_allow_multiple_values] +enum EStreamP2PScope { +k_estreamp2pscopeunknown = 0 +k_estreamp2pscopedisabled = 1 +k_estreamp2pscopeonlyme = 2 +k_estreamp2pscopefriends = 3 +k_estreamp2pscopeeveryone = 4 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_estreamp2pscope(e EStreamP2PScope, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_estreamp2pscope(buf []byte, tag_wiretype vproto.WireType) ?(int, EStreamP2PScope) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EStreamP2PScope(v) +} +[_allow_multiple_values] +enum EStreamHostPlayAudioPreference { +k_estreamhostplayaudiodefault = 0 +k_estreamhostplayaudioalways = 1 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_estreamhostplayaudiopreference(e EStreamHostPlayAudioPreference, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_estreamhostplayaudiopreference(buf []byte, tag_wiretype vproto.WireType) ?(int, EStreamHostPlayAudioPreference) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EStreamHostPlayAudioPreference(v) +} +[_allow_multiple_values] +enum EStreamingDataType { +k_estreamingaudiodata = 0 +k_estreamingvideodata = 1 +k_estreamingmicrophonedata = 2 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_estreamingdatatype(e EStreamingDataType, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_estreamingdatatype(buf []byte, tag_wiretype vproto.WireType) ?(int, EStreamingDataType) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EStreamingDataType(v) +} +[_allow_multiple_values] +enum EStreamMouseButton { +k_estreammousebuttonleft = 1 +k_estreammousebuttonright = 2 +k_estreammousebuttonmiddle = 16 +k_estreammousebuttonx1 = 32 +k_estreammousebuttonx2 = 64 +k_estreammousebuttonunknown = 4096 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_estreammousebutton(e EStreamMouseButton, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_estreammousebutton(buf []byte, tag_wiretype vproto.WireType) ?(int, EStreamMouseButton) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EStreamMouseButton(v) +} +[_allow_multiple_values] +enum EStreamMouseWheelDirection { +k_estreammousewheelup = 120 +k_estreammousewheeldown = -120 +k_estreammousewheelleft = 3 +k_estreammousewheelright = 4 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_estreammousewheeldirection(e EStreamMouseWheelDirection, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_estreammousewheeldirection(buf []byte, tag_wiretype vproto.WireType) ?(int, EStreamMouseWheelDirection) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EStreamMouseWheelDirection(v) +} +[_allow_multiple_values] +enum EStreamFramerateLimiter { +k_estreamframerateslowcapture = 1 +k_estreamframerateslowconvert = 2 +k_estreamframerateslowencode = 4 +k_estreamframerateslownetwork = 8 +k_estreamframerateslowdecode = 16 +k_estreamframerateslowgame = 32 +k_estreamframerateslowdisplay = 64 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_estreamframeratelimiter(e EStreamFramerateLimiter, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_estreamframeratelimiter(buf []byte, tag_wiretype vproto.WireType) ?(int, EStreamFramerateLimiter) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EStreamFramerateLimiter(v) +} +[_allow_multiple_values] +enum EStreamActivity { +k_estreamactivityidle = 1 +k_estreamactivitygame = 2 +k_estreamactivitydesktop = 3 +k_estreamactivitysecuredesktop = 4 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_estreamactivity(e EStreamActivity, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_estreamactivity(buf []byte, tag_wiretype vproto.WireType) ?(int, EStreamActivity) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EStreamActivity(v) +} +[_allow_multiple_values] +enum EStreamDataMessage { +k_estreamdatapacket = 1 +k_estreamdatalost = 2 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_estreamdatamessage(e EStreamDataMessage, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_estreamdatamessage(buf []byte, tag_wiretype vproto.WireType) ?(int, EStreamDataMessage) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EStreamDataMessage(v) +} +[_allow_multiple_values] +enum EAudioFormat { +k_eaudioformatnone = 0 +k_eaudioformat16bitlittleendian = 1 +k_eaudioformatfloat = 2 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_eaudioformat(e EAudioFormat, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_eaudioformat(buf []byte, tag_wiretype vproto.WireType) ?(int, EAudioFormat) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EAudioFormat(v) +} +[_allow_multiple_values] +enum EVideoFormat { +k_evideoformatnone = 0 +k_evideoformatyv12 = 1 +k_evideoformataccel = 2 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_evideoformat(e EVideoFormat, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_evideoformat(buf []byte, tag_wiretype vproto.WireType) ?(int, EVideoFormat) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EVideoFormat(v) +} +[_allow_multiple_values] +enum EStreamStatsMessage { +k_estreamstatsframeevents = 1 +k_estreamstatsdebugdump = 2 +k_estreamstatslogmessage = 3 +k_estreamstatsloguploadbegin = 4 +k_estreamstatsloguploaddata = 5 +k_estreamstatsloguploadcomplete = 6 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_estreamstatsmessage(e EStreamStatsMessage, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_estreamstatsmessage(buf []byte, tag_wiretype vproto.WireType) ?(int, EStreamStatsMessage) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EStreamStatsMessage(v) +} +[_allow_multiple_values] +enum EStreamFrameEvent { +k_estreaminputeventstart = 0 +k_estreaminputeventsend = 1 +k_estreaminputeventrecv = 2 +k_estreaminputeventqueued = 3 +k_estreaminputeventhandled = 4 +k_estreamframeeventstart = 5 +k_estreamframeeventcapturebegin = 6 +k_estreamframeeventcaptureend = 7 +k_estreamframeeventconvertbegin = 8 +k_estreamframeeventconvertend = 9 +k_estreamframeeventencodebegin = 10 +k_estreamframeeventencodeend = 11 +k_estreamframeeventsend = 12 +k_estreamframeeventrecv = 13 +k_estreamframeeventdecodebegin = 14 +k_estreamframeeventdecodeend = 15 +k_estreamframeeventuploadbegin = 16 +k_estreamframeeventuploadend = 17 +k_estreamframeeventcomplete = 18 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_estreamframeevent(e EStreamFrameEvent, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_estreamframeevent(buf []byte, tag_wiretype vproto.WireType) ?(int, EStreamFrameEvent) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EStreamFrameEvent(v) +} +[_allow_multiple_values] +enum EStreamFrameResult { +k_estreamframeresultpending = 0 +k_estreamframeresultdisplayed = 1 +k_estreamframeresultdroppednetworkslow = 2 +k_estreamframeresultdroppednetworklost = 3 +k_estreamframeresultdroppeddecodeslow = 4 +k_estreamframeresultdroppeddecodecorrupt = 5 +k_estreamframeresultdroppedlate = 6 +k_estreamframeresultdroppedreset = 7 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_estreamframeresult(e EStreamFrameResult, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_estreamframeresult(buf []byte, tag_wiretype vproto.WireType) ?(int, EStreamFrameResult) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EStreamFrameResult(v) +} +[_allow_multiple_values] +enum EFrameAccumulatedStat { +k_eframestatfps = 0 +k_eframestatcapturedurationms = 1 +k_eframestatconvertdurationms = 2 +k_eframestatencodedurationms = 3 +k_eframestatsteamdurationms = 4 +k_eframestatserverdurationms = 5 +k_eframestatnetworkdurationms = 6 +k_eframestatdecodedurationms = 7 +k_eframestatdisplaydurationms = 8 +k_eframestatclientdurationms = 9 +k_eframestatframedurationms = 10 +k_eframestatinputlatencyms = 11 +k_eframestatgamelatencyms = 12 +k_eframestatroundtriplatencyms = 13 +k_eframestatpingtimems = 14 +k_eframestatserverbitratekbitpersec = 15 +k_eframestatclientbitratekbitpersec = 16 +k_eframestatlinkbandwidthkbitpersec = 17 +k_eframestatpacketlosspercentage = 18 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_eframeaccumulatedstat(e EFrameAccumulatedStat, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_eframeaccumulatedstat(buf []byte, tag_wiretype vproto.WireType) ?(int, EFrameAccumulatedStat) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, EFrameAccumulatedStat(v) +} +[_allow_multiple_values] +enum ELogFileType { +k_elogfilesystemboot = 0 +k_elogfilesystemreset = 1 +k_elogfilesystemdebug = 2 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_elogfiletype(e ELogFileType, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_elogfiletype(buf []byte, tag_wiretype vproto.WireType) ?(int, ELogFileType) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, ELogFileType(v) +} +pub struct CDiscoveryPingRequest { +mut: +unknown_fields []vproto.UnknownField +pub mut: +sequence u32 +has_sequence bool +packet_size_requested u32 +has_packet_size_requested bool +} +pub fn (o &CDiscoveryPingRequest) pack() []byte { +mut res := []byte{} +if o.has_sequence { +res << vproto.pack_uint32_field(o.sequence, 1) +} + +if o.has_packet_size_requested { +res << vproto.pack_uint32_field(o.packet_size_requested, 2) +} + +return res +} + +pub fn cdiscoverypingrequest_unpack(buf []byte) ?CDiscoveryPingRequest { +mut res := CDiscoveryPingRequest{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_sequence = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.sequence = v +i = ii +} + +2 { +res.has_packet_size_requested = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.packet_size_requested = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdiscoverypingrequest() CDiscoveryPingRequest { +return CDiscoveryPingRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdiscoverypingrequest(o CDiscoveryPingRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdiscoverypingrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CDiscoveryPingRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdiscoverypingrequest_unpack(v)? +return i, unpacked +} +pub struct CDiscoveryPingResponse { +mut: +unknown_fields []vproto.UnknownField +pub mut: +sequence u32 +has_sequence bool +packet_size_received u32 +has_packet_size_received bool +} +pub fn (o &CDiscoveryPingResponse) pack() []byte { +mut res := []byte{} +if o.has_sequence { +res << vproto.pack_uint32_field(o.sequence, 1) +} + +if o.has_packet_size_received { +res << vproto.pack_uint32_field(o.packet_size_received, 2) +} + +return res +} + +pub fn cdiscoverypingresponse_unpack(buf []byte) ?CDiscoveryPingResponse { +mut res := CDiscoveryPingResponse{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_sequence = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.sequence = v +i = ii +} + +2 { +res.has_packet_size_received = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.packet_size_received = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdiscoverypingresponse() CDiscoveryPingResponse { +return CDiscoveryPingResponse{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdiscoverypingresponse(o CDiscoveryPingResponse, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdiscoverypingresponse(buf []byte, tag_wiretype vproto.WireType) ?(int, CDiscoveryPingResponse) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdiscoverypingresponse_unpack(v)? +return i, unpacked +} +pub struct CStreamingClientHandshakeInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +network_test int +has_network_test bool +} +pub fn (o &CStreamingClientHandshakeInfo) pack() []byte { +mut res := []byte{} +if o.has_network_test { +res << vproto.pack_int32_field(o.network_test, 2) +} + +return res +} + +pub fn cstreamingclienthandshakeinfo_unpack(buf []byte) ?CStreamingClientHandshakeInfo { +mut res := CStreamingClientHandshakeInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +2 { +res.has_network_test = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.network_test = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstreamingclienthandshakeinfo() CStreamingClientHandshakeInfo { +return CStreamingClientHandshakeInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstreamingclienthandshakeinfo(o CStreamingClientHandshakeInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstreamingclienthandshakeinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CStreamingClientHandshakeInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstreamingclienthandshakeinfo_unpack(v)? +return i, unpacked +} +pub struct CClientHandshakeMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +info CStreamingClientHandshakeInfo +} +pub fn (o &CClientHandshakeMsg) pack() []byte { +mut res := []byte{} +res << zzz_vproto_internal_pack_cstreamingclienthandshakeinfo(o.info, 1) + +return res +} + +pub fn cclienthandshakemsg_unpack(buf []byte) ?CClientHandshakeMsg { +mut res := CClientHandshakeMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := zzz_vproto_internal_unpack_cstreamingclienthandshakeinfo(cur_buf, tag_wiretype.wire_type)? +res.info = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cclienthandshakemsg() CClientHandshakeMsg { +return CClientHandshakeMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cclienthandshakemsg(o CClientHandshakeMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cclienthandshakemsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CClientHandshakeMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cclienthandshakemsg_unpack(v)? +return i, unpacked +} +pub struct CStreamingServerHandshakeInfo { +mut: +unknown_fields []vproto.UnknownField +pub mut: +mtu int +has_mtu bool +} +pub fn (o &CStreamingServerHandshakeInfo) pack() []byte { +mut res := []byte{} +if o.has_mtu { +res << vproto.pack_int32_field(o.mtu, 1) +} + +return res +} + +pub fn cstreamingserverhandshakeinfo_unpack(buf []byte) ?CStreamingServerHandshakeInfo { +mut res := CStreamingServerHandshakeInfo{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_mtu = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.mtu = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstreamingserverhandshakeinfo() CStreamingServerHandshakeInfo { +return CStreamingServerHandshakeInfo{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstreamingserverhandshakeinfo(o CStreamingServerHandshakeInfo, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstreamingserverhandshakeinfo(buf []byte, tag_wiretype vproto.WireType) ?(int, CStreamingServerHandshakeInfo) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstreamingserverhandshakeinfo_unpack(v)? +return i, unpacked +} +pub struct CServerHandshakeMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +info CStreamingServerHandshakeInfo +} +pub fn (o &CServerHandshakeMsg) pack() []byte { +mut res := []byte{} +res << zzz_vproto_internal_pack_cstreamingserverhandshakeinfo(o.info, 1) + +return res +} + +pub fn cserverhandshakemsg_unpack(buf []byte) ?CServerHandshakeMsg { +mut res := CServerHandshakeMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := zzz_vproto_internal_unpack_cstreamingserverhandshakeinfo(cur_buf, tag_wiretype.wire_type)? +res.info = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cserverhandshakemsg() CServerHandshakeMsg { +return CServerHandshakeMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cserverhandshakemsg(o CServerHandshakeMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cserverhandshakemsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CServerHandshakeMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cserverhandshakemsg_unpack(v)? +return i, unpacked +} +pub struct CAuthenticationRequestMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +token []byte +has_token bool +version EStreamVersion +has_version bool +} +pub fn (o &CAuthenticationRequestMsg) pack() []byte { +mut res := []byte{} +if o.has_token { +res << vproto.pack_bytes_field(o.token, 1) +} + +if o.has_version { +res << zzz_vproto_internal_pack_estreamversion(o.version, 2) +} + +return res +} + +pub fn cauthenticationrequestmsg_unpack(buf []byte) ?CAuthenticationRequestMsg { +mut res := CAuthenticationRequestMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_token = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.token = v +i = ii +} + +2 { +res.has_version = true +ii, v := zzz_vproto_internal_unpack_estreamversion(cur_buf, tag_wiretype.wire_type)? +res.version = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cauthenticationrequestmsg() CAuthenticationRequestMsg { +return CAuthenticationRequestMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cauthenticationrequestmsg(o CAuthenticationRequestMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cauthenticationrequestmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CAuthenticationRequestMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cauthenticationrequestmsg_unpack(v)? +return i, unpacked +} +[_allow_multiple_values] +enum CAuthenticationResponseMsgAuthenticationResult { +succeeded = 0 +failed = 1 +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_pack_cauthenticationresponsemsgauthenticationresult(e CAuthenticationResponseMsgAuthenticationResult, num u32) []byte { +return vproto.pack_int32_field(int(e), num) +} +// FOR INTERNAL USE ONLY +fn zzz_vproto_internal_unpack_cauthenticationresponsemsgauthenticationresult(buf []byte, tag_wiretype vproto.WireType) ?(int, CAuthenticationResponseMsgAuthenticationResult) { +i, v := vproto.unpack_int32_field(buf, tag_wiretype)? +return i, CAuthenticationResponseMsgAuthenticationResult(v) +} +pub struct CAuthenticationResponseMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +result CAuthenticationResponseMsgAuthenticationResult +has_result bool +version EStreamVersion +has_version bool +} +pub fn (o &CAuthenticationResponseMsg) pack() []byte { +mut res := []byte{} +if o.has_result { +res << zzz_vproto_internal_pack_cauthenticationresponsemsgauthenticationresult(o.result, 1) +} + +if o.has_version { +res << zzz_vproto_internal_pack_estreamversion(o.version, 2) +} + +return res +} + +pub fn cauthenticationresponsemsg_unpack(buf []byte) ?CAuthenticationResponseMsg { +mut res := CAuthenticationResponseMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_result = true +ii, v := zzz_vproto_internal_unpack_cauthenticationresponsemsgauthenticationresult(cur_buf, tag_wiretype.wire_type)? +res.result = v +i = ii +} + +2 { +res.has_version = true +ii, v := zzz_vproto_internal_unpack_estreamversion(cur_buf, tag_wiretype.wire_type)? +res.version = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cauthenticationresponsemsg() CAuthenticationResponseMsg { +return CAuthenticationResponseMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cauthenticationresponsemsg(o CAuthenticationResponseMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cauthenticationresponsemsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CAuthenticationResponseMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cauthenticationresponsemsg_unpack(v)? +return i, unpacked +} +pub struct CKeepAliveMsg { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CKeepAliveMsg) pack() []byte { +res := []byte{} +return res +} + +pub fn ckeepalivemsg_unpack(buf []byte) ?CKeepAliveMsg { +res := CKeepAliveMsg{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ckeepalivemsg() CKeepAliveMsg { +return CKeepAliveMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ckeepalivemsg(o CKeepAliveMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ckeepalivemsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CKeepAliveMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ckeepalivemsg_unpack(v)? +return i, unpacked +} +pub struct CStartNetworkTestMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +frames u32 +has_frames bool +framerate u32 +has_framerate bool +bitrate_kbps u32 +has_bitrate_kbps bool +burst_bitrate_kbps u32 +has_burst_bitrate_kbps bool +bandwidth_test bool +has_bandwidth_test bool +} +pub fn (o &CStartNetworkTestMsg) pack() []byte { +mut res := []byte{} +if o.has_frames { +res << vproto.pack_uint32_field(o.frames, 1) +} + +if o.has_framerate { +res << vproto.pack_uint32_field(o.framerate, 2) +} + +if o.has_bitrate_kbps { +res << vproto.pack_uint32_field(o.bitrate_kbps, 3) +} + +if o.has_burst_bitrate_kbps { +res << vproto.pack_uint32_field(o.burst_bitrate_kbps, 4) +} + +if o.has_bandwidth_test { +res << vproto.pack_bool_field(o.bandwidth_test, 5) +} + +return res +} + +pub fn cstartnetworktestmsg_unpack(buf []byte) ?CStartNetworkTestMsg { +mut res := CStartNetworkTestMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_frames = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.frames = v +i = ii +} + +2 { +res.has_framerate = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.framerate = v +i = ii +} + +3 { +res.has_bitrate_kbps = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.bitrate_kbps = v +i = ii +} + +4 { +res.has_burst_bitrate_kbps = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.burst_bitrate_kbps = v +i = ii +} + +5 { +res.has_bandwidth_test = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.bandwidth_test = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstartnetworktestmsg() CStartNetworkTestMsg { +return CStartNetworkTestMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstartnetworktestmsg(o CStartNetworkTestMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstartnetworktestmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CStartNetworkTestMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstartnetworktestmsg_unpack(v)? +return i, unpacked +} +pub struct CStreamVideoMode { +mut: +unknown_fields []vproto.UnknownField +pub mut: +width u32 +height u32 +refresh_rate u32 +has_refresh_rate bool +refresh_rate_numerator u32 +has_refresh_rate_numerator bool +refresh_rate_denominator u32 +has_refresh_rate_denominator bool +} +pub fn (o &CStreamVideoMode) pack() []byte { +mut res := []byte{} +res << vproto.pack_uint32_field(o.width, 1) + +res << vproto.pack_uint32_field(o.height, 2) + +if o.has_refresh_rate { +res << vproto.pack_uint32_field(o.refresh_rate, 3) +} + +if o.has_refresh_rate_numerator { +res << vproto.pack_uint32_field(o.refresh_rate_numerator, 4) +} + +if o.has_refresh_rate_denominator { +res << vproto.pack_uint32_field(o.refresh_rate_denominator, 5) +} + +return res +} + +pub fn cstreamvideomode_unpack(buf []byte) ?CStreamVideoMode { +mut res := CStreamVideoMode{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.width = v +i = ii +} + +2 { +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.height = v +i = ii +} + +3 { +res.has_refresh_rate = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.refresh_rate = v +i = ii +} + +4 { +res.has_refresh_rate_numerator = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.refresh_rate_numerator = v +i = ii +} + +5 { +res.has_refresh_rate_denominator = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.refresh_rate_denominator = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstreamvideomode() CStreamVideoMode { +return CStreamVideoMode{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstreamvideomode(o CStreamVideoMode, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstreamvideomode(buf []byte, tag_wiretype vproto.WireType) ?(int, CStreamVideoMode) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstreamvideomode_unpack(v)? +return i, unpacked +} +pub struct CStreamingClientCaps { +mut: +unknown_fields []vproto.UnknownField +pub mut: +system_info string +has_system_info bool +system_can_suspend bool +has_system_can_suspend bool +maximum_decode_bitrate_kbps int +has_maximum_decode_bitrate_kbps bool +maximum_burst_bitrate_kbps int +has_maximum_burst_bitrate_kbps bool +supports_video_hevc bool +has_supports_video_hevc bool +disable_steam_store bool +has_disable_steam_store bool +disable_client_cursor bool +has_disable_client_cursor bool +disable_intel_hardware_encoding bool +has_disable_intel_hardware_encoding bool +disable_amd_hardware_encoding bool +has_disable_amd_hardware_encoding bool +disable_nvidia_hardware_encoding bool +has_disable_nvidia_hardware_encoding bool +form_factor int +has_form_factor bool +} +pub fn (o &CStreamingClientCaps) pack() []byte { +mut res := []byte{} +if o.has_system_info { +res << vproto.pack_string_field(o.system_info, 1) +} + +if o.has_system_can_suspend { +res << vproto.pack_bool_field(o.system_can_suspend, 2) +} + +if o.has_maximum_decode_bitrate_kbps { +res << vproto.pack_int32_field(o.maximum_decode_bitrate_kbps, 3) +} + +if o.has_maximum_burst_bitrate_kbps { +res << vproto.pack_int32_field(o.maximum_burst_bitrate_kbps, 4) +} + +if o.has_supports_video_hevc { +res << vproto.pack_bool_field(o.supports_video_hevc, 5) +} + +if o.has_disable_steam_store { +res << vproto.pack_bool_field(o.disable_steam_store, 6) +} + +if o.has_disable_client_cursor { +res << vproto.pack_bool_field(o.disable_client_cursor, 7) +} + +if o.has_disable_intel_hardware_encoding { +res << vproto.pack_bool_field(o.disable_intel_hardware_encoding, 8) +} + +if o.has_disable_amd_hardware_encoding { +res << vproto.pack_bool_field(o.disable_amd_hardware_encoding, 9) +} + +if o.has_disable_nvidia_hardware_encoding { +res << vproto.pack_bool_field(o.disable_nvidia_hardware_encoding, 10) +} + +if o.has_form_factor { +res << vproto.pack_int32_field(o.form_factor, 11) +} + +return res +} + +pub fn cstreamingclientcaps_unpack(buf []byte) ?CStreamingClientCaps { +mut res := CStreamingClientCaps{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_system_info = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.system_info = v +i = ii +} + +2 { +res.has_system_can_suspend = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.system_can_suspend = v +i = ii +} + +3 { +res.has_maximum_decode_bitrate_kbps = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.maximum_decode_bitrate_kbps = v +i = ii +} + +4 { +res.has_maximum_burst_bitrate_kbps = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.maximum_burst_bitrate_kbps = v +i = ii +} + +5 { +res.has_supports_video_hevc = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.supports_video_hevc = v +i = ii +} + +6 { +res.has_disable_steam_store = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.disable_steam_store = v +i = ii +} + +7 { +res.has_disable_client_cursor = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.disable_client_cursor = v +i = ii +} + +8 { +res.has_disable_intel_hardware_encoding = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.disable_intel_hardware_encoding = v +i = ii +} + +9 { +res.has_disable_amd_hardware_encoding = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.disable_amd_hardware_encoding = v +i = ii +} + +10 { +res.has_disable_nvidia_hardware_encoding = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.disable_nvidia_hardware_encoding = v +i = ii +} + +11 { +res.has_form_factor = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.form_factor = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstreamingclientcaps() CStreamingClientCaps { +return CStreamingClientCaps{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstreamingclientcaps(o CStreamingClientCaps, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstreamingclientcaps(buf []byte, tag_wiretype vproto.WireType) ?(int, CStreamingClientCaps) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstreamingclientcaps_unpack(v)? +return i, unpacked +} +pub struct CStreamingClientConfig { +mut: +unknown_fields []vproto.UnknownField +pub mut: +quality EStreamQualityPreference +has_quality bool +maximum_resolution_x u32 +has_maximum_resolution_x bool +maximum_resolution_y u32 +has_maximum_resolution_y bool +maximum_framerate_numerator u32 +has_maximum_framerate_numerator bool +maximum_framerate_denominator u32 +has_maximum_framerate_denominator bool +maximum_bitrate_kbps int +has_maximum_bitrate_kbps bool +enable_hardware_decoding bool +has_enable_hardware_decoding bool +enable_performance_overlay bool +has_enable_performance_overlay bool +enable_video_streaming bool +has_enable_video_streaming bool +enable_audio_streaming bool +has_enable_audio_streaming bool +enable_input_streaming bool +has_enable_input_streaming bool +audio_channels int +has_audio_channels bool +enable_video_hevc bool +has_enable_video_hevc bool +enable_performance_icons bool +has_enable_performance_icons bool +enable_microphone_streaming bool +has_enable_microphone_streaming bool +controller_overlay_hotkey string +has_controller_overlay_hotkey bool +enable_touch_controller bool +has_enable_touch_controller bool +p2p_scope EStreamP2PScope +has_p2p_scope bool +} +pub fn (o &CStreamingClientConfig) pack() []byte { +mut res := []byte{} +if o.has_quality { +res << zzz_vproto_internal_pack_estreamqualitypreference(o.quality, 1) +} + +if o.has_maximum_resolution_x { +res << vproto.pack_uint32_field(o.maximum_resolution_x, 2) +} + +if o.has_maximum_resolution_y { +res << vproto.pack_uint32_field(o.maximum_resolution_y, 3) +} + +if o.has_maximum_framerate_numerator { +res << vproto.pack_uint32_field(o.maximum_framerate_numerator, 4) +} + +if o.has_maximum_framerate_denominator { +res << vproto.pack_uint32_field(o.maximum_framerate_denominator, 5) +} + +if o.has_maximum_bitrate_kbps { +res << vproto.pack_int32_field(o.maximum_bitrate_kbps, 6) +} + +if o.has_enable_hardware_decoding { +res << vproto.pack_bool_field(o.enable_hardware_decoding, 7) +} + +if o.has_enable_performance_overlay { +res << vproto.pack_bool_field(o.enable_performance_overlay, 8) +} + +if o.has_enable_video_streaming { +res << vproto.pack_bool_field(o.enable_video_streaming, 9) +} + +if o.has_enable_audio_streaming { +res << vproto.pack_bool_field(o.enable_audio_streaming, 10) +} + +if o.has_enable_input_streaming { +res << vproto.pack_bool_field(o.enable_input_streaming, 11) +} + +if o.has_audio_channels { +res << vproto.pack_int32_field(o.audio_channels, 12) +} + +if o.has_enable_video_hevc { +res << vproto.pack_bool_field(o.enable_video_hevc, 13) +} + +if o.has_enable_performance_icons { +res << vproto.pack_bool_field(o.enable_performance_icons, 14) +} + +if o.has_enable_microphone_streaming { +res << vproto.pack_bool_field(o.enable_microphone_streaming, 15) +} + +if o.has_controller_overlay_hotkey { +res << vproto.pack_string_field(o.controller_overlay_hotkey, 16) +} + +if o.has_enable_touch_controller { +res << vproto.pack_bool_field(o.enable_touch_controller, 17) +} + +if o.has_p2p_scope { +res << zzz_vproto_internal_pack_estreamp2pscope(o.p2p_scope, 18) +} + +return res +} + +pub fn cstreamingclientconfig_unpack(buf []byte) ?CStreamingClientConfig { +mut res := CStreamingClientConfig{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_quality = true +ii, v := zzz_vproto_internal_unpack_estreamqualitypreference(cur_buf, tag_wiretype.wire_type)? +res.quality = v +i = ii +} + +2 { +res.has_maximum_resolution_x = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.maximum_resolution_x = v +i = ii +} + +3 { +res.has_maximum_resolution_y = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.maximum_resolution_y = v +i = ii +} + +4 { +res.has_maximum_framerate_numerator = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.maximum_framerate_numerator = v +i = ii +} + +5 { +res.has_maximum_framerate_denominator = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.maximum_framerate_denominator = v +i = ii +} + +6 { +res.has_maximum_bitrate_kbps = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.maximum_bitrate_kbps = v +i = ii +} + +7 { +res.has_enable_hardware_decoding = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enable_hardware_decoding = v +i = ii +} + +8 { +res.has_enable_performance_overlay = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enable_performance_overlay = v +i = ii +} + +9 { +res.has_enable_video_streaming = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enable_video_streaming = v +i = ii +} + +10 { +res.has_enable_audio_streaming = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enable_audio_streaming = v +i = ii +} + +11 { +res.has_enable_input_streaming = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enable_input_streaming = v +i = ii +} + +12 { +res.has_audio_channels = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.audio_channels = v +i = ii +} + +13 { +res.has_enable_video_hevc = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enable_video_hevc = v +i = ii +} + +14 { +res.has_enable_performance_icons = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enable_performance_icons = v +i = ii +} + +15 { +res.has_enable_microphone_streaming = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enable_microphone_streaming = v +i = ii +} + +16 { +res.has_controller_overlay_hotkey = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.controller_overlay_hotkey = v +i = ii +} + +17 { +res.has_enable_touch_controller = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enable_touch_controller = v +i = ii +} + +18 { +res.has_p2p_scope = true +ii, v := zzz_vproto_internal_unpack_estreamp2pscope(cur_buf, tag_wiretype.wire_type)? +res.p2p_scope = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstreamingclientconfig() CStreamingClientConfig { +return CStreamingClientConfig{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstreamingclientconfig(o CStreamingClientConfig, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstreamingclientconfig(buf []byte, tag_wiretype vproto.WireType) ?(int, CStreamingClientConfig) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstreamingclientconfig_unpack(v)? +return i, unpacked +} +pub struct CStreamingServerConfig { +mut: +unknown_fields []vproto.UnknownField +pub mut: +change_desktop_resolution bool +has_change_desktop_resolution bool +dynamically_adjust_resolution bool +has_dynamically_adjust_resolution bool +enable_capture_nvfbc bool +has_enable_capture_nvfbc bool +enable_hardware_encoding_nvidia bool +has_enable_hardware_encoding_nvidia bool +enable_hardware_encoding_amd bool +has_enable_hardware_encoding_amd bool +enable_hardware_encoding_intel bool +has_enable_hardware_encoding_intel bool +software_encoding_threads int +has_software_encoding_threads bool +enable_traffic_priority bool +has_enable_traffic_priority bool +host_play_audio EStreamHostPlayAudioPreference +has_host_play_audio bool +} +pub fn (o &CStreamingServerConfig) pack() []byte { +mut res := []byte{} +if o.has_change_desktop_resolution { +res << vproto.pack_bool_field(o.change_desktop_resolution, 1) +} + +if o.has_dynamically_adjust_resolution { +res << vproto.pack_bool_field(o.dynamically_adjust_resolution, 2) +} + +if o.has_enable_capture_nvfbc { +res << vproto.pack_bool_field(o.enable_capture_nvfbc, 3) +} + +if o.has_enable_hardware_encoding_nvidia { +res << vproto.pack_bool_field(o.enable_hardware_encoding_nvidia, 4) +} + +if o.has_enable_hardware_encoding_amd { +res << vproto.pack_bool_field(o.enable_hardware_encoding_amd, 5) +} + +if o.has_enable_hardware_encoding_intel { +res << vproto.pack_bool_field(o.enable_hardware_encoding_intel, 6) +} + +if o.has_software_encoding_threads { +res << vproto.pack_int32_field(o.software_encoding_threads, 7) +} + +if o.has_enable_traffic_priority { +res << vproto.pack_bool_field(o.enable_traffic_priority, 8) +} + +if o.has_host_play_audio { +res << zzz_vproto_internal_pack_estreamhostplayaudiopreference(o.host_play_audio, 9) +} + +return res +} + +pub fn cstreamingserverconfig_unpack(buf []byte) ?CStreamingServerConfig { +mut res := CStreamingServerConfig{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_change_desktop_resolution = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.change_desktop_resolution = v +i = ii +} + +2 { +res.has_dynamically_adjust_resolution = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.dynamically_adjust_resolution = v +i = ii +} + +3 { +res.has_enable_capture_nvfbc = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enable_capture_nvfbc = v +i = ii +} + +4 { +res.has_enable_hardware_encoding_nvidia = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enable_hardware_encoding_nvidia = v +i = ii +} + +5 { +res.has_enable_hardware_encoding_amd = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enable_hardware_encoding_amd = v +i = ii +} + +6 { +res.has_enable_hardware_encoding_intel = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enable_hardware_encoding_intel = v +i = ii +} + +7 { +res.has_software_encoding_threads = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.software_encoding_threads = v +i = ii +} + +8 { +res.has_enable_traffic_priority = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enable_traffic_priority = v +i = ii +} + +9 { +res.has_host_play_audio = true +ii, v := zzz_vproto_internal_unpack_estreamhostplayaudiopreference(cur_buf, tag_wiretype.wire_type)? +res.host_play_audio = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstreamingserverconfig() CStreamingServerConfig { +return CStreamingServerConfig{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstreamingserverconfig(o CStreamingServerConfig, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstreamingserverconfig(buf []byte, tag_wiretype vproto.WireType) ?(int, CStreamingServerConfig) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstreamingserverconfig_unpack(v)? +return i, unpacked +} +pub struct CNegotiatedConfig { +mut: +unknown_fields []vproto.UnknownField +pub mut: +reliable_data bool +has_reliable_data bool +selected_audio_codec EStreamAudioCodec +has_selected_audio_codec bool +selected_video_codec EStreamVideoCodec +has_selected_video_codec bool +available_video_modes []CStreamVideoMode +enable_remote_hid bool +has_enable_remote_hid bool +enable_touch_input bool +has_enable_touch_input bool +} +pub fn (o &CNegotiatedConfig) pack() []byte { +mut res := []byte{} +if o.has_reliable_data { +res << vproto.pack_bool_field(o.reliable_data, 1) +} + +if o.has_selected_audio_codec { +res << zzz_vproto_internal_pack_estreamaudiocodec(o.selected_audio_codec, 2) +} + +if o.has_selected_video_codec { +res << zzz_vproto_internal_pack_estreamvideocodec(o.selected_video_codec, 3) +} + +// [packed=false] +for _, x in o.available_video_modes { +res << zzz_vproto_internal_pack_cstreamvideomode(x, 4) +} + +if o.has_enable_remote_hid { +res << vproto.pack_bool_field(o.enable_remote_hid, 5) +} + +if o.has_enable_touch_input { +res << vproto.pack_bool_field(o.enable_touch_input, 6) +} + +return res +} + +pub fn cnegotiatedconfig_unpack(buf []byte) ?CNegotiatedConfig { +mut res := CNegotiatedConfig{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_reliable_data = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.reliable_data = v +i = ii +} + +2 { +res.has_selected_audio_codec = true +ii, v := zzz_vproto_internal_unpack_estreamaudiocodec(cur_buf, tag_wiretype.wire_type)? +res.selected_audio_codec = v +i = ii +} + +3 { +res.has_selected_video_codec = true +ii, v := zzz_vproto_internal_unpack_estreamvideocodec(cur_buf, tag_wiretype.wire_type)? +res.selected_video_codec = v +i = ii +} + +4 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cstreamvideomode(cur_buf, tag_wiretype.wire_type)? +res.available_video_modes << v +i = ii +} + +5 { +res.has_enable_remote_hid = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enable_remote_hid = v +i = ii +} + +6 { +res.has_enable_touch_input = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enable_touch_input = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cnegotiatedconfig() CNegotiatedConfig { +return CNegotiatedConfig{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cnegotiatedconfig(o CNegotiatedConfig, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cnegotiatedconfig(buf []byte, tag_wiretype vproto.WireType) ?(int, CNegotiatedConfig) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cnegotiatedconfig_unpack(v)? +return i, unpacked +} +pub struct CNegotiationInitMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +reliable_data bool +has_reliable_data bool +supported_audio_codecs []EStreamAudioCodec +supported_video_codecs []EStreamVideoCodec +supports_remote_hid bool +has_supports_remote_hid bool +supports_touch_input bool +has_supports_touch_input bool +} +pub fn (o &CNegotiationInitMsg) pack() []byte { +mut res := []byte{} +if o.has_reliable_data { +res << vproto.pack_bool_field(o.reliable_data, 1) +} + +// [packed=false] +for _, x in o.supported_audio_codecs { +res << zzz_vproto_internal_pack_estreamaudiocodec(x, 2) +} + +// [packed=false] +for _, x in o.supported_video_codecs { +res << zzz_vproto_internal_pack_estreamvideocodec(x, 3) +} + +if o.has_supports_remote_hid { +res << vproto.pack_bool_field(o.supports_remote_hid, 4) +} + +if o.has_supports_touch_input { +res << vproto.pack_bool_field(o.supports_touch_input, 5) +} + +return res +} + +pub fn cnegotiationinitmsg_unpack(buf []byte) ?CNegotiationInitMsg { +mut res := CNegotiationInitMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_reliable_data = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.reliable_data = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_estreamaudiocodec(cur_buf, tag_wiretype.wire_type)? +res.supported_audio_codecs << v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_estreamvideocodec(cur_buf, tag_wiretype.wire_type)? +res.supported_video_codecs << v +i = ii +} + +4 { +res.has_supports_remote_hid = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.supports_remote_hid = v +i = ii +} + +5 { +res.has_supports_touch_input = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.supports_touch_input = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cnegotiationinitmsg() CNegotiationInitMsg { +return CNegotiationInitMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cnegotiationinitmsg(o CNegotiationInitMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cnegotiationinitmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CNegotiationInitMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cnegotiationinitmsg_unpack(v)? +return i, unpacked +} +pub struct CNegotiationSetConfigMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +config CNegotiatedConfig +streaming_client_config CStreamingClientConfig +has_streaming_client_config bool +streaming_client_caps CStreamingClientCaps +has_streaming_client_caps bool +} +pub fn (o &CNegotiationSetConfigMsg) pack() []byte { +mut res := []byte{} +res << zzz_vproto_internal_pack_cnegotiatedconfig(o.config, 1) + +if o.has_streaming_client_config { +res << zzz_vproto_internal_pack_cstreamingclientconfig(o.streaming_client_config, 2) +} + +if o.has_streaming_client_caps { +res << zzz_vproto_internal_pack_cstreamingclientcaps(o.streaming_client_caps, 3) +} + +return res +} + +pub fn cnegotiationsetconfigmsg_unpack(buf []byte) ?CNegotiationSetConfigMsg { +mut res := CNegotiationSetConfigMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := zzz_vproto_internal_unpack_cnegotiatedconfig(cur_buf, tag_wiretype.wire_type)? +res.config = v +i = ii +} + +2 { +res.has_streaming_client_config = true +ii, v := zzz_vproto_internal_unpack_cstreamingclientconfig(cur_buf, tag_wiretype.wire_type)? +res.streaming_client_config = v +i = ii +} + +3 { +res.has_streaming_client_caps = true +ii, v := zzz_vproto_internal_unpack_cstreamingclientcaps(cur_buf, tag_wiretype.wire_type)? +res.streaming_client_caps = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cnegotiationsetconfigmsg() CNegotiationSetConfigMsg { +return CNegotiationSetConfigMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cnegotiationsetconfigmsg(o CNegotiationSetConfigMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cnegotiationsetconfigmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CNegotiationSetConfigMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cnegotiationsetconfigmsg_unpack(v)? +return i, unpacked +} +pub struct CNegotiationCompleteMsg { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CNegotiationCompleteMsg) pack() []byte { +res := []byte{} +return res +} + +pub fn cnegotiationcompletemsg_unpack(buf []byte) ?CNegotiationCompleteMsg { +res := CNegotiationCompleteMsg{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cnegotiationcompletemsg() CNegotiationCompleteMsg { +return CNegotiationCompleteMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cnegotiationcompletemsg(o CNegotiationCompleteMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cnegotiationcompletemsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CNegotiationCompleteMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cnegotiationcompletemsg_unpack(v)? +return i, unpacked +} +pub struct CStartAudioDataMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +channel u32 +codec EStreamAudioCodec +has_codec bool +codec_data []byte +has_codec_data bool +frequency u32 +has_frequency bool +channels u32 +has_channels bool +} +pub fn (o &CStartAudioDataMsg) pack() []byte { +mut res := []byte{} +res << vproto.pack_uint32_field(o.channel, 2) + +if o.has_codec { +res << zzz_vproto_internal_pack_estreamaudiocodec(o.codec, 3) +} + +if o.has_codec_data { +res << vproto.pack_bytes_field(o.codec_data, 4) +} + +if o.has_frequency { +res << vproto.pack_uint32_field(o.frequency, 5) +} + +if o.has_channels { +res << vproto.pack_uint32_field(o.channels, 6) +} + +return res +} + +pub fn cstartaudiodatamsg_unpack(buf []byte) ?CStartAudioDataMsg { +mut res := CStartAudioDataMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +2 { +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.channel = v +i = ii +} + +3 { +res.has_codec = true +ii, v := zzz_vproto_internal_unpack_estreamaudiocodec(cur_buf, tag_wiretype.wire_type)? +res.codec = v +i = ii +} + +4 { +res.has_codec_data = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.codec_data = v +i = ii +} + +5 { +res.has_frequency = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.frequency = v +i = ii +} + +6 { +res.has_channels = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.channels = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstartaudiodatamsg() CStartAudioDataMsg { +return CStartAudioDataMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstartaudiodatamsg(o CStartAudioDataMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstartaudiodatamsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CStartAudioDataMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstartaudiodatamsg_unpack(v)? +return i, unpacked +} +pub struct CStopAudioDataMsg { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CStopAudioDataMsg) pack() []byte { +res := []byte{} +return res +} + +pub fn cstopaudiodatamsg_unpack(buf []byte) ?CStopAudioDataMsg { +res := CStopAudioDataMsg{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstopaudiodatamsg() CStopAudioDataMsg { +return CStopAudioDataMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstopaudiodatamsg(o CStopAudioDataMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstopaudiodatamsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CStopAudioDataMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstopaudiodatamsg_unpack(v)? +return i, unpacked +} +pub struct CStartVideoDataMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +channel u32 +codec EStreamVideoCodec +has_codec bool +codec_data []byte +has_codec_data bool +width u32 +has_width bool +height u32 +has_height bool +} +pub fn (o &CStartVideoDataMsg) pack() []byte { +mut res := []byte{} +res << vproto.pack_uint32_field(o.channel, 1) + +if o.has_codec { +res << zzz_vproto_internal_pack_estreamvideocodec(o.codec, 2) +} + +if o.has_codec_data { +res << vproto.pack_bytes_field(o.codec_data, 3) +} + +if o.has_width { +res << vproto.pack_uint32_field(o.width, 4) +} + +if o.has_height { +res << vproto.pack_uint32_field(o.height, 5) +} + +return res +} + +pub fn cstartvideodatamsg_unpack(buf []byte) ?CStartVideoDataMsg { +mut res := CStartVideoDataMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.channel = v +i = ii +} + +2 { +res.has_codec = true +ii, v := zzz_vproto_internal_unpack_estreamvideocodec(cur_buf, tag_wiretype.wire_type)? +res.codec = v +i = ii +} + +3 { +res.has_codec_data = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.codec_data = v +i = ii +} + +4 { +res.has_width = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.width = v +i = ii +} + +5 { +res.has_height = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.height = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstartvideodatamsg() CStartVideoDataMsg { +return CStartVideoDataMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstartvideodatamsg(o CStartVideoDataMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstartvideodatamsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CStartVideoDataMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstartvideodatamsg_unpack(v)? +return i, unpacked +} +pub struct CStopVideoDataMsg { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CStopVideoDataMsg) pack() []byte { +res := []byte{} +return res +} + +pub fn cstopvideodatamsg_unpack(buf []byte) ?CStopVideoDataMsg { +res := CStopVideoDataMsg{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstopvideodatamsg() CStopVideoDataMsg { +return CStopVideoDataMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstopvideodatamsg(o CStopVideoDataMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstopvideodatamsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CStopVideoDataMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstopvideodatamsg_unpack(v)? +return i, unpacked +} +pub struct CRecordedInput { +mut: +unknown_fields []vproto.UnknownField +pub mut: +@type EStreamControlMessage +has_type bool +timestamp u32 +has_timestamp bool +} +pub fn (o &CRecordedInput) pack() []byte { +mut res := []byte{} +if o.has_type { +res << zzz_vproto_internal_pack_estreamcontrolmessage(o.@type, 1) +} + +if o.has_timestamp { +res << vproto.pack_uint32_field(o.timestamp, 2) +} + +return res +} + +pub fn crecordedinput_unpack(buf []byte) ?CRecordedInput { +mut res := CRecordedInput{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_type = true +ii, v := zzz_vproto_internal_unpack_estreamcontrolmessage(cur_buf, tag_wiretype.wire_type)? +res.@type = v +i = ii +} + +2 { +res.has_timestamp = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_crecordedinput() CRecordedInput { +return CRecordedInput{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_crecordedinput(o CRecordedInput, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_crecordedinput(buf []byte, tag_wiretype vproto.WireType) ?(int, CRecordedInput) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := crecordedinput_unpack(v)? +return i, unpacked +} +pub struct CRecordedInputStream { +mut: +unknown_fields []vproto.UnknownField +pub mut: +entries []CRecordedInput +} +pub fn (o &CRecordedInputStream) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.entries { +res << zzz_vproto_internal_pack_crecordedinput(x, 1) +} + +return res +} + +pub fn crecordedinputstream_unpack(buf []byte) ?CRecordedInputStream { +mut res := CRecordedInputStream{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_crecordedinput(cur_buf, tag_wiretype.wire_type)? +res.entries << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_crecordedinputstream() CRecordedInputStream { +return CRecordedInputStream{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_crecordedinputstream(o CRecordedInputStream, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_crecordedinputstream(buf []byte, tag_wiretype vproto.WireType) ?(int, CRecordedInputStream) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := crecordedinputstream_unpack(v)? +return i, unpacked +} +pub struct CInputLatencyTestMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +input_mark u32 +color u32 +has_color bool +} +pub fn (o &CInputLatencyTestMsg) pack() []byte { +mut res := []byte{} +res << vproto.pack_uint32_field(o.input_mark, 1) + +if o.has_color { +res << vproto.pack_uint32_field(o.color, 2) +} + +return res +} + +pub fn cinputlatencytestmsg_unpack(buf []byte) ?CInputLatencyTestMsg { +mut res := CInputLatencyTestMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.input_mark = v +i = ii +} + +2 { +res.has_color = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.color = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinputlatencytestmsg() CInputLatencyTestMsg { +return CInputLatencyTestMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinputlatencytestmsg(o CInputLatencyTestMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinputlatencytestmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CInputLatencyTestMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinputlatencytestmsg_unpack(v)? +return i, unpacked +} +pub struct CInputTouchFingerDownMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +input_mark u32 +has_input_mark bool +fingerid u64 +has_fingerid bool +x_normalized f32 +has_x_normalized bool +y_normalized f32 +has_y_normalized bool +} +pub fn (o &CInputTouchFingerDownMsg) pack() []byte { +mut res := []byte{} +if o.has_input_mark { +res << vproto.pack_uint32_field(o.input_mark, 1) +} + +if o.has_fingerid { +res << vproto.pack_uint64_field(o.fingerid, 2) +} + +if o.has_x_normalized { +res << vproto.pack_float_field(o.x_normalized, 3) +} + +if o.has_y_normalized { +res << vproto.pack_float_field(o.y_normalized, 4) +} + +return res +} + +pub fn cinputtouchfingerdownmsg_unpack(buf []byte) ?CInputTouchFingerDownMsg { +mut res := CInputTouchFingerDownMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_input_mark = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.input_mark = v +i = ii +} + +2 { +res.has_fingerid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.fingerid = v +i = ii +} + +3 { +res.has_x_normalized = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.x_normalized = v +i = ii +} + +4 { +res.has_y_normalized = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.y_normalized = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinputtouchfingerdownmsg() CInputTouchFingerDownMsg { +return CInputTouchFingerDownMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinputtouchfingerdownmsg(o CInputTouchFingerDownMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinputtouchfingerdownmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CInputTouchFingerDownMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinputtouchfingerdownmsg_unpack(v)? +return i, unpacked +} +pub struct CInputTouchFingerMotionMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +input_mark u32 +has_input_mark bool +fingerid u64 +has_fingerid bool +x_normalized f32 +has_x_normalized bool +y_normalized f32 +has_y_normalized bool +} +pub fn (o &CInputTouchFingerMotionMsg) pack() []byte { +mut res := []byte{} +if o.has_input_mark { +res << vproto.pack_uint32_field(o.input_mark, 1) +} + +if o.has_fingerid { +res << vproto.pack_uint64_field(o.fingerid, 2) +} + +if o.has_x_normalized { +res << vproto.pack_float_field(o.x_normalized, 3) +} + +if o.has_y_normalized { +res << vproto.pack_float_field(o.y_normalized, 4) +} + +return res +} + +pub fn cinputtouchfingermotionmsg_unpack(buf []byte) ?CInputTouchFingerMotionMsg { +mut res := CInputTouchFingerMotionMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_input_mark = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.input_mark = v +i = ii +} + +2 { +res.has_fingerid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.fingerid = v +i = ii +} + +3 { +res.has_x_normalized = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.x_normalized = v +i = ii +} + +4 { +res.has_y_normalized = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.y_normalized = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinputtouchfingermotionmsg() CInputTouchFingerMotionMsg { +return CInputTouchFingerMotionMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinputtouchfingermotionmsg(o CInputTouchFingerMotionMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinputtouchfingermotionmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CInputTouchFingerMotionMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinputtouchfingermotionmsg_unpack(v)? +return i, unpacked +} +pub struct CInputTouchFingerUpMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +input_mark u32 +has_input_mark bool +fingerid u64 +has_fingerid bool +x_normalized f32 +has_x_normalized bool +y_normalized f32 +has_y_normalized bool +} +pub fn (o &CInputTouchFingerUpMsg) pack() []byte { +mut res := []byte{} +if o.has_input_mark { +res << vproto.pack_uint32_field(o.input_mark, 1) +} + +if o.has_fingerid { +res << vproto.pack_uint64_field(o.fingerid, 2) +} + +if o.has_x_normalized { +res << vproto.pack_float_field(o.x_normalized, 3) +} + +if o.has_y_normalized { +res << vproto.pack_float_field(o.y_normalized, 4) +} + +return res +} + +pub fn cinputtouchfingerupmsg_unpack(buf []byte) ?CInputTouchFingerUpMsg { +mut res := CInputTouchFingerUpMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_input_mark = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.input_mark = v +i = ii +} + +2 { +res.has_fingerid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.fingerid = v +i = ii +} + +3 { +res.has_x_normalized = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.x_normalized = v +i = ii +} + +4 { +res.has_y_normalized = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.y_normalized = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinputtouchfingerupmsg() CInputTouchFingerUpMsg { +return CInputTouchFingerUpMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinputtouchfingerupmsg(o CInputTouchFingerUpMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinputtouchfingerupmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CInputTouchFingerUpMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinputtouchfingerupmsg_unpack(v)? +return i, unpacked +} +pub struct CInputMouseMotionMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +input_mark u32 +has_input_mark bool +x_normalized f32 +has_x_normalized bool +y_normalized f32 +has_y_normalized bool +dx int +has_dx bool +dy int +has_dy bool +} +pub fn (o &CInputMouseMotionMsg) pack() []byte { +mut res := []byte{} +if o.has_input_mark { +res << vproto.pack_uint32_field(o.input_mark, 1) +} + +if o.has_x_normalized { +res << vproto.pack_float_field(o.x_normalized, 2) +} + +if o.has_y_normalized { +res << vproto.pack_float_field(o.y_normalized, 3) +} + +if o.has_dx { +res << vproto.pack_int32_field(o.dx, 4) +} + +if o.has_dy { +res << vproto.pack_int32_field(o.dy, 5) +} + +return res +} + +pub fn cinputmousemotionmsg_unpack(buf []byte) ?CInputMouseMotionMsg { +mut res := CInputMouseMotionMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_input_mark = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.input_mark = v +i = ii +} + +2 { +res.has_x_normalized = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.x_normalized = v +i = ii +} + +3 { +res.has_y_normalized = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.y_normalized = v +i = ii +} + +4 { +res.has_dx = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.dx = v +i = ii +} + +5 { +res.has_dy = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.dy = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinputmousemotionmsg() CInputMouseMotionMsg { +return CInputMouseMotionMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinputmousemotionmsg(o CInputMouseMotionMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinputmousemotionmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CInputMouseMotionMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinputmousemotionmsg_unpack(v)? +return i, unpacked +} +pub struct CInputMouseWheelMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +input_mark u32 +has_input_mark bool +direction EStreamMouseWheelDirection +} +pub fn (o &CInputMouseWheelMsg) pack() []byte { +mut res := []byte{} +if o.has_input_mark { +res << vproto.pack_uint32_field(o.input_mark, 1) +} + +res << zzz_vproto_internal_pack_estreammousewheeldirection(o.direction, 2) + +return res +} + +pub fn cinputmousewheelmsg_unpack(buf []byte) ?CInputMouseWheelMsg { +mut res := CInputMouseWheelMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_input_mark = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.input_mark = v +i = ii +} + +2 { +ii, v := zzz_vproto_internal_unpack_estreammousewheeldirection(cur_buf, tag_wiretype.wire_type)? +res.direction = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinputmousewheelmsg() CInputMouseWheelMsg { +return CInputMouseWheelMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinputmousewheelmsg(o CInputMouseWheelMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinputmousewheelmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CInputMouseWheelMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinputmousewheelmsg_unpack(v)? +return i, unpacked +} +pub struct CInputMouseDownMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +input_mark u32 +has_input_mark bool +button EStreamMouseButton +} +pub fn (o &CInputMouseDownMsg) pack() []byte { +mut res := []byte{} +if o.has_input_mark { +res << vproto.pack_uint32_field(o.input_mark, 1) +} + +res << zzz_vproto_internal_pack_estreammousebutton(o.button, 2) + +return res +} + +pub fn cinputmousedownmsg_unpack(buf []byte) ?CInputMouseDownMsg { +mut res := CInputMouseDownMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_input_mark = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.input_mark = v +i = ii +} + +2 { +ii, v := zzz_vproto_internal_unpack_estreammousebutton(cur_buf, tag_wiretype.wire_type)? +res.button = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinputmousedownmsg() CInputMouseDownMsg { +return CInputMouseDownMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinputmousedownmsg(o CInputMouseDownMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinputmousedownmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CInputMouseDownMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinputmousedownmsg_unpack(v)? +return i, unpacked +} +pub struct CInputMouseUpMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +input_mark u32 +has_input_mark bool +button EStreamMouseButton +} +pub fn (o &CInputMouseUpMsg) pack() []byte { +mut res := []byte{} +if o.has_input_mark { +res << vproto.pack_uint32_field(o.input_mark, 1) +} + +res << zzz_vproto_internal_pack_estreammousebutton(o.button, 2) + +return res +} + +pub fn cinputmouseupmsg_unpack(buf []byte) ?CInputMouseUpMsg { +mut res := CInputMouseUpMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_input_mark = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.input_mark = v +i = ii +} + +2 { +ii, v := zzz_vproto_internal_unpack_estreammousebutton(cur_buf, tag_wiretype.wire_type)? +res.button = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinputmouseupmsg() CInputMouseUpMsg { +return CInputMouseUpMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinputmouseupmsg(o CInputMouseUpMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinputmouseupmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CInputMouseUpMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinputmouseupmsg_unpack(v)? +return i, unpacked +} +pub struct CInputKeyDownMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +input_mark u32 +has_input_mark bool +scancode u32 +} +pub fn (o &CInputKeyDownMsg) pack() []byte { +mut res := []byte{} +if o.has_input_mark { +res << vproto.pack_uint32_field(o.input_mark, 1) +} + +res << vproto.pack_uint32_field(o.scancode, 2) + +return res +} + +pub fn cinputkeydownmsg_unpack(buf []byte) ?CInputKeyDownMsg { +mut res := CInputKeyDownMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_input_mark = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.input_mark = v +i = ii +} + +2 { +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.scancode = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinputkeydownmsg() CInputKeyDownMsg { +return CInputKeyDownMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinputkeydownmsg(o CInputKeyDownMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinputkeydownmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CInputKeyDownMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinputkeydownmsg_unpack(v)? +return i, unpacked +} +pub struct CInputKeyUpMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +input_mark u32 +has_input_mark bool +scancode u32 +} +pub fn (o &CInputKeyUpMsg) pack() []byte { +mut res := []byte{} +if o.has_input_mark { +res << vproto.pack_uint32_field(o.input_mark, 1) +} + +res << vproto.pack_uint32_field(o.scancode, 2) + +return res +} + +pub fn cinputkeyupmsg_unpack(buf []byte) ?CInputKeyUpMsg { +mut res := CInputKeyUpMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_input_mark = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.input_mark = v +i = ii +} + +2 { +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.scancode = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinputkeyupmsg() CInputKeyUpMsg { +return CInputKeyUpMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinputkeyupmsg(o CInputKeyUpMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinputkeyupmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CInputKeyUpMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinputkeyupmsg_unpack(v)? +return i, unpacked +} +pub struct CInputTextMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +input_mark u32 +has_input_mark bool +text_utf8 string +} +pub fn (o &CInputTextMsg) pack() []byte { +mut res := []byte{} +if o.has_input_mark { +res << vproto.pack_uint32_field(o.input_mark, 1) +} + +res << vproto.pack_string_field(o.text_utf8, 2) + +return res +} + +pub fn cinputtextmsg_unpack(buf []byte) ?CInputTextMsg { +mut res := CInputTextMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_input_mark = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.input_mark = v +i = ii +} + +2 { +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.text_utf8 = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cinputtextmsg() CInputTextMsg { +return CInputTextMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cinputtextmsg(o CInputTextMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cinputtextmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CInputTextMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cinputtextmsg_unpack(v)? +return i, unpacked +} +pub struct CSetTitleMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +text string +has_text bool +} +pub fn (o &CSetTitleMsg) pack() []byte { +mut res := []byte{} +if o.has_text { +res << vproto.pack_string_field(o.text, 1) +} + +return res +} + +pub fn csettitlemsg_unpack(buf []byte) ?CSetTitleMsg { +mut res := CSetTitleMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_text = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.text = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csettitlemsg() CSetTitleMsg { +return CSetTitleMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csettitlemsg(o CSetTitleMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csettitlemsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CSetTitleMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csettitlemsg_unpack(v)? +return i, unpacked +} +pub struct CSetCaptureSizeMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +width int +has_width bool +height int +has_height bool +} +pub fn (o &CSetCaptureSizeMsg) pack() []byte { +mut res := []byte{} +if o.has_width { +res << vproto.pack_int32_field(o.width, 1) +} + +if o.has_height { +res << vproto.pack_int32_field(o.height, 2) +} + +return res +} + +pub fn csetcapturesizemsg_unpack(buf []byte) ?CSetCaptureSizeMsg { +mut res := CSetCaptureSizeMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_width = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.width = v +i = ii +} + +2 { +res.has_height = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.height = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csetcapturesizemsg() CSetCaptureSizeMsg { +return CSetCaptureSizeMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csetcapturesizemsg(o CSetCaptureSizeMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csetcapturesizemsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CSetCaptureSizeMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csetcapturesizemsg_unpack(v)? +return i, unpacked +} +pub struct CSetIconMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +width int +has_width bool +height int +has_height bool +image []byte +has_image bool +} +pub fn (o &CSetIconMsg) pack() []byte { +mut res := []byte{} +if o.has_width { +res << vproto.pack_int32_field(o.width, 1) +} + +if o.has_height { +res << vproto.pack_int32_field(o.height, 2) +} + +if o.has_image { +res << vproto.pack_bytes_field(o.image, 3) +} + +return res +} + +pub fn cseticonmsg_unpack(buf []byte) ?CSetIconMsg { +mut res := CSetIconMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_width = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.width = v +i = ii +} + +2 { +res.has_height = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.height = v +i = ii +} + +3 { +res.has_image = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.image = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cseticonmsg() CSetIconMsg { +return CSetIconMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cseticonmsg(o CSetIconMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cseticonmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CSetIconMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cseticonmsg_unpack(v)? +return i, unpacked +} +pub struct CSetFlashStateMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +flags u32 +has_flags bool +count u32 +has_count bool +timeout_ms u32 +has_timeout_ms bool +} +pub fn (o &CSetFlashStateMsg) pack() []byte { +mut res := []byte{} +if o.has_flags { +res << vproto.pack_uint32_field(o.flags, 1) +} + +if o.has_count { +res << vproto.pack_uint32_field(o.count, 2) +} + +if o.has_timeout_ms { +res << vproto.pack_uint32_field(o.timeout_ms, 3) +} + +return res +} + +pub fn csetflashstatemsg_unpack(buf []byte) ?CSetFlashStateMsg { +mut res := CSetFlashStateMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_flags = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.flags = v +i = ii +} + +2 { +res.has_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.count = v +i = ii +} + +3 { +res.has_timeout_ms = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.timeout_ms = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csetflashstatemsg() CSetFlashStateMsg { +return CSetFlashStateMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csetflashstatemsg(o CSetFlashStateMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csetflashstatemsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CSetFlashStateMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csetflashstatemsg_unpack(v)? +return i, unpacked +} +pub struct CShowCursorMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +x_normalized f32 +has_x_normalized bool +y_normalized f32 +has_y_normalized bool +} +pub fn (o &CShowCursorMsg) pack() []byte { +mut res := []byte{} +if o.has_x_normalized { +res << vproto.pack_float_field(o.x_normalized, 1) +} + +if o.has_y_normalized { +res << vproto.pack_float_field(o.y_normalized, 2) +} + +return res +} + +pub fn cshowcursormsg_unpack(buf []byte) ?CShowCursorMsg { +mut res := CShowCursorMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_x_normalized = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.x_normalized = v +i = ii +} + +2 { +res.has_y_normalized = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.y_normalized = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cshowcursormsg() CShowCursorMsg { +return CShowCursorMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cshowcursormsg(o CShowCursorMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cshowcursormsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CShowCursorMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cshowcursormsg_unpack(v)? +return i, unpacked +} +pub struct CHideCursorMsg { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CHideCursorMsg) pack() []byte { +res := []byte{} +return res +} + +pub fn chidecursormsg_unpack(buf []byte) ?CHideCursorMsg { +res := CHideCursorMsg{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_chidecursormsg() CHideCursorMsg { +return CHideCursorMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_chidecursormsg(o CHideCursorMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_chidecursormsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CHideCursorMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := chidecursormsg_unpack(v)? +return i, unpacked +} +pub struct CSetCursorMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +cursor_id u64 +} +pub fn (o &CSetCursorMsg) pack() []byte { +mut res := []byte{} +res << vproto.pack_uint64_field(o.cursor_id, 1) + +return res +} + +pub fn csetcursormsg_unpack(buf []byte) ?CSetCursorMsg { +mut res := CSetCursorMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.cursor_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csetcursormsg() CSetCursorMsg { +return CSetCursorMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csetcursormsg(o CSetCursorMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csetcursormsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CSetCursorMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csetcursormsg_unpack(v)? +return i, unpacked +} +pub struct CGetCursorImageMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +cursor_id u64 +} +pub fn (o &CGetCursorImageMsg) pack() []byte { +mut res := []byte{} +res << vproto.pack_uint64_field(o.cursor_id, 1) + +return res +} + +pub fn cgetcursorimagemsg_unpack(buf []byte) ?CGetCursorImageMsg { +mut res := CGetCursorImageMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.cursor_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgetcursorimagemsg() CGetCursorImageMsg { +return CGetCursorImageMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgetcursorimagemsg(o CGetCursorImageMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgetcursorimagemsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CGetCursorImageMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgetcursorimagemsg_unpack(v)? +return i, unpacked +} +pub struct CSetCursorImageMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +cursor_id u64 +width int +has_width bool +height int +has_height bool +hot_x int +has_hot_x bool +hot_y int +has_hot_y bool +image []byte +has_image bool +} +pub fn (o &CSetCursorImageMsg) pack() []byte { +mut res := []byte{} +res << vproto.pack_uint64_field(o.cursor_id, 1) + +if o.has_width { +res << vproto.pack_int32_field(o.width, 2) +} + +if o.has_height { +res << vproto.pack_int32_field(o.height, 3) +} + +if o.has_hot_x { +res << vproto.pack_int32_field(o.hot_x, 4) +} + +if o.has_hot_y { +res << vproto.pack_int32_field(o.hot_y, 5) +} + +if o.has_image { +res << vproto.pack_bytes_field(o.image, 6) +} + +return res +} + +pub fn csetcursorimagemsg_unpack(buf []byte) ?CSetCursorImageMsg { +mut res := CSetCursorImageMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.cursor_id = v +i = ii +} + +2 { +res.has_width = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.width = v +i = ii +} + +3 { +res.has_height = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.height = v +i = ii +} + +4 { +res.has_hot_x = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.hot_x = v +i = ii +} + +5 { +res.has_hot_y = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.hot_y = v +i = ii +} + +6 { +res.has_image = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.image = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csetcursorimagemsg() CSetCursorImageMsg { +return CSetCursorImageMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csetcursorimagemsg(o CSetCursorImageMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csetcursorimagemsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CSetCursorImageMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csetcursorimagemsg_unpack(v)? +return i, unpacked +} +pub struct CVideoDecoderInfoMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +info string +has_info bool +threads int +has_threads bool +} +pub fn (o &CVideoDecoderInfoMsg) pack() []byte { +mut res := []byte{} +if o.has_info { +res << vproto.pack_string_field(o.info, 1) +} + +if o.has_threads { +res << vproto.pack_int32_field(o.threads, 2) +} + +return res +} + +pub fn cvideodecoderinfomsg_unpack(buf []byte) ?CVideoDecoderInfoMsg { +mut res := CVideoDecoderInfoMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_info = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.info = v +i = ii +} + +2 { +res.has_threads = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.threads = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cvideodecoderinfomsg() CVideoDecoderInfoMsg { +return CVideoDecoderInfoMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cvideodecoderinfomsg(o CVideoDecoderInfoMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cvideodecoderinfomsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CVideoDecoderInfoMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cvideodecoderinfomsg_unpack(v)? +return i, unpacked +} +pub struct CVideoEncoderInfoMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +info string +has_info bool +} +pub fn (o &CVideoEncoderInfoMsg) pack() []byte { +mut res := []byte{} +if o.has_info { +res << vproto.pack_string_field(o.info, 1) +} + +return res +} + +pub fn cvideoencoderinfomsg_unpack(buf []byte) ?CVideoEncoderInfoMsg { +mut res := CVideoEncoderInfoMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_info = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.info = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cvideoencoderinfomsg() CVideoEncoderInfoMsg { +return CVideoEncoderInfoMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cvideoencoderinfomsg(o CVideoEncoderInfoMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cvideoencoderinfomsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CVideoEncoderInfoMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cvideoencoderinfomsg_unpack(v)? +return i, unpacked +} +pub struct CPauseMsg { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CPauseMsg) pack() []byte { +res := []byte{} +return res +} + +pub fn cpausemsg_unpack(buf []byte) ?CPauseMsg { +res := CPauseMsg{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cpausemsg() CPauseMsg { +return CPauseMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cpausemsg(o CPauseMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cpausemsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CPauseMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cpausemsg_unpack(v)? +return i, unpacked +} +pub struct CResumeMsg { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CResumeMsg) pack() []byte { +res := []byte{} +return res +} + +pub fn cresumemsg_unpack(buf []byte) ?CResumeMsg { +res := CResumeMsg{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cresumemsg() CResumeMsg { +return CResumeMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cresumemsg(o CResumeMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cresumemsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CResumeMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cresumemsg_unpack(v)? +return i, unpacked +} +pub struct CEnableHighResCaptureMsg { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CEnableHighResCaptureMsg) pack() []byte { +res := []byte{} +return res +} + +pub fn cenablehighrescapturemsg_unpack(buf []byte) ?CEnableHighResCaptureMsg { +res := CEnableHighResCaptureMsg{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cenablehighrescapturemsg() CEnableHighResCaptureMsg { +return CEnableHighResCaptureMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cenablehighrescapturemsg(o CEnableHighResCaptureMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cenablehighrescapturemsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CEnableHighResCaptureMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cenablehighrescapturemsg_unpack(v)? +return i, unpacked +} +pub struct CDisableHighResCaptureMsg { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CDisableHighResCaptureMsg) pack() []byte { +res := []byte{} +return res +} + +pub fn cdisablehighrescapturemsg_unpack(buf []byte) ?CDisableHighResCaptureMsg { +res := CDisableHighResCaptureMsg{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdisablehighrescapturemsg() CDisableHighResCaptureMsg { +return CDisableHighResCaptureMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdisablehighrescapturemsg(o CDisableHighResCaptureMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdisablehighrescapturemsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CDisableHighResCaptureMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdisablehighrescapturemsg_unpack(v)? +return i, unpacked +} +pub struct CToggleMagnificationMsg { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CToggleMagnificationMsg) pack() []byte { +res := []byte{} +return res +} + +pub fn ctogglemagnificationmsg_unpack(buf []byte) ?CToggleMagnificationMsg { +res := CToggleMagnificationMsg{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctogglemagnificationmsg() CToggleMagnificationMsg { +return CToggleMagnificationMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctogglemagnificationmsg(o CToggleMagnificationMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctogglemagnificationmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CToggleMagnificationMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctogglemagnificationmsg_unpack(v)? +return i, unpacked +} +pub struct CSetCapslockMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +pressed bool +has_pressed bool +} +pub fn (o &CSetCapslockMsg) pack() []byte { +mut res := []byte{} +if o.has_pressed { +res << vproto.pack_bool_field(o.pressed, 1) +} + +return res +} + +pub fn csetcapslockmsg_unpack(buf []byte) ?CSetCapslockMsg { +mut res := CSetCapslockMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_pressed = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.pressed = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csetcapslockmsg() CSetCapslockMsg { +return CSetCapslockMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csetcapslockmsg(o CSetCapslockMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csetcapslockmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CSetCapslockMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csetcapslockmsg_unpack(v)? +return i, unpacked +} +pub struct CStreamingKeymapEntry { +mut: +unknown_fields []vproto.UnknownField +pub mut: +scancode int +has_scancode bool +normal_keycode int +has_normal_keycode bool +shift_keycode int +has_shift_keycode bool +capslock_keycode int +has_capslock_keycode bool +shift_capslock_keycode int +has_shift_capslock_keycode bool +altgr_keycode int +has_altgr_keycode bool +altgr_shift_keycode int +has_altgr_shift_keycode bool +altgr_capslock_keycode int +has_altgr_capslock_keycode bool +altgr_shift_capslock_keycode int +has_altgr_shift_capslock_keycode bool +} +pub fn (o &CStreamingKeymapEntry) pack() []byte { +mut res := []byte{} +if o.has_scancode { +res << vproto.pack_int32_field(o.scancode, 1) +} + +if o.has_normal_keycode { +res << vproto.pack_int32_field(o.normal_keycode, 2) +} + +if o.has_shift_keycode { +res << vproto.pack_int32_field(o.shift_keycode, 3) +} + +if o.has_capslock_keycode { +res << vproto.pack_int32_field(o.capslock_keycode, 4) +} + +if o.has_shift_capslock_keycode { +res << vproto.pack_int32_field(o.shift_capslock_keycode, 5) +} + +if o.has_altgr_keycode { +res << vproto.pack_int32_field(o.altgr_keycode, 6) +} + +if o.has_altgr_shift_keycode { +res << vproto.pack_int32_field(o.altgr_shift_keycode, 7) +} + +if o.has_altgr_capslock_keycode { +res << vproto.pack_int32_field(o.altgr_capslock_keycode, 8) +} + +if o.has_altgr_shift_capslock_keycode { +res << vproto.pack_int32_field(o.altgr_shift_capslock_keycode, 9) +} + +return res +} + +pub fn cstreamingkeymapentry_unpack(buf []byte) ?CStreamingKeymapEntry { +mut res := CStreamingKeymapEntry{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_scancode = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.scancode = v +i = ii +} + +2 { +res.has_normal_keycode = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.normal_keycode = v +i = ii +} + +3 { +res.has_shift_keycode = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.shift_keycode = v +i = ii +} + +4 { +res.has_capslock_keycode = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.capslock_keycode = v +i = ii +} + +5 { +res.has_shift_capslock_keycode = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.shift_capslock_keycode = v +i = ii +} + +6 { +res.has_altgr_keycode = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.altgr_keycode = v +i = ii +} + +7 { +res.has_altgr_shift_keycode = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.altgr_shift_keycode = v +i = ii +} + +8 { +res.has_altgr_capslock_keycode = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.altgr_capslock_keycode = v +i = ii +} + +9 { +res.has_altgr_shift_capslock_keycode = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.altgr_shift_capslock_keycode = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstreamingkeymapentry() CStreamingKeymapEntry { +return CStreamingKeymapEntry{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstreamingkeymapentry(o CStreamingKeymapEntry, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstreamingkeymapentry(buf []byte, tag_wiretype vproto.WireType) ?(int, CStreamingKeymapEntry) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstreamingkeymapentry_unpack(v)? +return i, unpacked +} +pub struct CStreamingKeymap { +mut: +unknown_fields []vproto.UnknownField +pub mut: +entries []CStreamingKeymapEntry +} +pub fn (o &CStreamingKeymap) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.entries { +res << zzz_vproto_internal_pack_cstreamingkeymapentry(x, 1) +} + +return res +} + +pub fn cstreamingkeymap_unpack(buf []byte) ?CStreamingKeymap { +mut res := CStreamingKeymap{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cstreamingkeymapentry(cur_buf, tag_wiretype.wire_type)? +res.entries << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstreamingkeymap() CStreamingKeymap { +return CStreamingKeymap{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstreamingkeymap(o CStreamingKeymap, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstreamingkeymap(buf []byte, tag_wiretype vproto.WireType) ?(int, CStreamingKeymap) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstreamingkeymap_unpack(v)? +return i, unpacked +} +pub struct CSetKeymapMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +keymap CStreamingKeymap +has_keymap bool +} +pub fn (o &CSetKeymapMsg) pack() []byte { +mut res := []byte{} +if o.has_keymap { +res << zzz_vproto_internal_pack_cstreamingkeymap(o.keymap, 1) +} + +return res +} + +pub fn csetkeymapmsg_unpack(buf []byte) ?CSetKeymapMsg { +mut res := CSetKeymapMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_keymap = true +ii, v := zzz_vproto_internal_unpack_cstreamingkeymap(cur_buf, tag_wiretype.wire_type)? +res.keymap = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csetkeymapmsg() CSetKeymapMsg { +return CSetKeymapMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csetkeymapmsg(o CSetKeymapMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csetkeymapmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CSetKeymapMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csetkeymapmsg_unpack(v)? +return i, unpacked +} +pub struct CStopRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CStopRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn cstoprequest_unpack(buf []byte) ?CStopRequest { +res := CStopRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstoprequest() CStopRequest { +return CStopRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstoprequest(o CStopRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstoprequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CStopRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstoprequest_unpack(v)? +return i, unpacked +} +pub struct CQuitRequest { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CQuitRequest) pack() []byte { +res := []byte{} +return res +} + +pub fn cquitrequest_unpack(buf []byte) ?CQuitRequest { +res := CQuitRequest{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cquitrequest() CQuitRequest { +return CQuitRequest{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cquitrequest(o CQuitRequest, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cquitrequest(buf []byte, tag_wiretype vproto.WireType) ?(int, CQuitRequest) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cquitrequest_unpack(v)? +return i, unpacked +} +pub struct CDeleteCursorMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +cursor_id u64 +} +pub fn (o &CDeleteCursorMsg) pack() []byte { +mut res := []byte{} +res << vproto.pack_uint64_field(o.cursor_id, 1) + +return res +} + +pub fn cdeletecursormsg_unpack(buf []byte) ?CDeleteCursorMsg { +mut res := CDeleteCursorMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.cursor_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdeletecursormsg() CDeleteCursorMsg { +return CDeleteCursorMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdeletecursormsg(o CDeleteCursorMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdeletecursormsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CDeleteCursorMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdeletecursormsg_unpack(v)? +return i, unpacked +} +pub struct CSetStreamingClientConfig { +mut: +unknown_fields []vproto.UnknownField +pub mut: +config CStreamingClientConfig +} +pub fn (o &CSetStreamingClientConfig) pack() []byte { +mut res := []byte{} +res << zzz_vproto_internal_pack_cstreamingclientconfig(o.config, 1) + +return res +} + +pub fn csetstreamingclientconfig_unpack(buf []byte) ?CSetStreamingClientConfig { +mut res := CSetStreamingClientConfig{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := zzz_vproto_internal_unpack_cstreamingclientconfig(cur_buf, tag_wiretype.wire_type)? +res.config = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csetstreamingclientconfig() CSetStreamingClientConfig { +return CSetStreamingClientConfig{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csetstreamingclientconfig(o CSetStreamingClientConfig, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csetstreamingclientconfig(buf []byte, tag_wiretype vproto.WireType) ?(int, CSetStreamingClientConfig) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csetstreamingclientconfig_unpack(v)? +return i, unpacked +} +pub struct CSetQoSMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +use_qos bool +} +pub fn (o &CSetQoSMsg) pack() []byte { +mut res := []byte{} +res << vproto.pack_bool_field(o.use_qos, 1) + +return res +} + +pub fn csetqosmsg_unpack(buf []byte) ?CSetQoSMsg { +mut res := CSetQoSMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.use_qos = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csetqosmsg() CSetQoSMsg { +return CSetQoSMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csetqosmsg(o CSetQoSMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csetqosmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CSetQoSMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csetqosmsg_unpack(v)? +return i, unpacked +} +pub struct CSetTargetFramerateMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +framerate u32 +reasons u32 +has_reasons bool +framerate_numerator u32 +has_framerate_numerator bool +framerate_denominator u32 +has_framerate_denominator bool +} +pub fn (o &CSetTargetFramerateMsg) pack() []byte { +mut res := []byte{} +res << vproto.pack_uint32_field(o.framerate, 1) + +if o.has_reasons { +res << vproto.pack_uint32_field(o.reasons, 2) +} + +if o.has_framerate_numerator { +res << vproto.pack_uint32_field(o.framerate_numerator, 3) +} + +if o.has_framerate_denominator { +res << vproto.pack_uint32_field(o.framerate_denominator, 4) +} + +return res +} + +pub fn csettargetframeratemsg_unpack(buf []byte) ?CSetTargetFramerateMsg { +mut res := CSetTargetFramerateMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.framerate = v +i = ii +} + +2 { +res.has_reasons = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.reasons = v +i = ii +} + +3 { +res.has_framerate_numerator = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.framerate_numerator = v +i = ii +} + +4 { +res.has_framerate_denominator = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.framerate_denominator = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csettargetframeratemsg() CSetTargetFramerateMsg { +return CSetTargetFramerateMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csettargetframeratemsg(o CSetTargetFramerateMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csettargetframeratemsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CSetTargetFramerateMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csettargetframeratemsg_unpack(v)? +return i, unpacked +} +pub struct CSetTargetBitrateMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +bitrate int +} +pub fn (o &CSetTargetBitrateMsg) pack() []byte { +mut res := []byte{} +res << vproto.pack_int32_field(o.bitrate, 1) + +return res +} + +pub fn csettargetbitratemsg_unpack(buf []byte) ?CSetTargetBitrateMsg { +mut res := CSetTargetBitrateMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.bitrate = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csettargetbitratemsg() CSetTargetBitrateMsg { +return CSetTargetBitrateMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csettargetbitratemsg(o CSetTargetBitrateMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csettargetbitratemsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CSetTargetBitrateMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csettargetbitratemsg_unpack(v)? +return i, unpacked +} +pub struct COverlayEnabledMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +enabled bool +} +pub fn (o &COverlayEnabledMsg) pack() []byte { +mut res := []byte{} +res << vproto.pack_bool_field(o.enabled, 1) + +return res +} + +pub fn coverlayenabledmsg_unpack(buf []byte) ?COverlayEnabledMsg { +mut res := COverlayEnabledMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enabled = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_coverlayenabledmsg() COverlayEnabledMsg { +return COverlayEnabledMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_coverlayenabledmsg(o COverlayEnabledMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_coverlayenabledmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, COverlayEnabledMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := coverlayenabledmsg_unpack(v)? +return i, unpacked +} +pub struct CSetGammaRampMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +gamma_ramp []byte +has_gamma_ramp bool +} +pub fn (o &CSetGammaRampMsg) pack() []byte { +mut res := []byte{} +if o.has_gamma_ramp { +res << vproto.pack_bytes_field(o.gamma_ramp, 1) +} + +return res +} + +pub fn csetgammarampmsg_unpack(buf []byte) ?CSetGammaRampMsg { +mut res := CSetGammaRampMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_gamma_ramp = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.gamma_ramp = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csetgammarampmsg() CSetGammaRampMsg { +return CSetGammaRampMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csetgammarampmsg(o CSetGammaRampMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csetgammarampmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CSetGammaRampMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csetgammarampmsg_unpack(v)? +return i, unpacked +} +pub struct CSetActivityMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +activity EStreamActivity +has_activity bool +appid u32 +has_appid bool +gameid u64 +has_gameid bool +} +pub fn (o &CSetActivityMsg) pack() []byte { +mut res := []byte{} +if o.has_activity { +res << zzz_vproto_internal_pack_estreamactivity(o.activity, 1) +} + +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 2) +} + +if o.has_gameid { +res << vproto.pack_uint64_field(o.gameid, 3) +} + +return res +} + +pub fn csetactivitymsg_unpack(buf []byte) ?CSetActivityMsg { +mut res := CSetActivityMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_activity = true +ii, v := zzz_vproto_internal_unpack_estreamactivity(cur_buf, tag_wiretype.wire_type)? +res.activity = v +i = ii +} + +2 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +3 { +res.has_gameid = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.gameid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csetactivitymsg() CSetActivityMsg { +return CSetActivityMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csetactivitymsg(o CSetActivityMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csetactivitymsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CSetActivityMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csetactivitymsg_unpack(v)? +return i, unpacked +} +pub struct CSystemSuspendMsg { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CSystemSuspendMsg) pack() []byte { +res := []byte{} +return res +} + +pub fn csystemsuspendmsg_unpack(buf []byte) ?CSystemSuspendMsg { +res := CSystemSuspendMsg{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csystemsuspendmsg() CSystemSuspendMsg { +return CSystemSuspendMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csystemsuspendmsg(o CSystemSuspendMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csystemsuspendmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CSystemSuspendMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csystemsuspendmsg_unpack(v)? +return i, unpacked +} +pub struct CVirtualHereRequestMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +hostname string +has_hostname bool +} +pub fn (o &CVirtualHereRequestMsg) pack() []byte { +mut res := []byte{} +if o.has_hostname { +res << vproto.pack_string_field(o.hostname, 1) +} + +return res +} + +pub fn cvirtualhererequestmsg_unpack(buf []byte) ?CVirtualHereRequestMsg { +mut res := CVirtualHereRequestMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_hostname = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.hostname = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cvirtualhererequestmsg() CVirtualHereRequestMsg { +return CVirtualHereRequestMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cvirtualhererequestmsg(o CVirtualHereRequestMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cvirtualhererequestmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CVirtualHereRequestMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cvirtualhererequestmsg_unpack(v)? +return i, unpacked +} +pub struct CVirtualHereReadyMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +licensed_device_count u32 +has_licensed_device_count bool +} +pub fn (o &CVirtualHereReadyMsg) pack() []byte { +mut res := []byte{} +if o.has_licensed_device_count { +res << vproto.pack_uint32_field(o.licensed_device_count, 1) +} + +return res +} + +pub fn cvirtualherereadymsg_unpack(buf []byte) ?CVirtualHereReadyMsg { +mut res := CVirtualHereReadyMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_licensed_device_count = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.licensed_device_count = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cvirtualherereadymsg() CVirtualHereReadyMsg { +return CVirtualHereReadyMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cvirtualherereadymsg(o CVirtualHereReadyMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cvirtualherereadymsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CVirtualHereReadyMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cvirtualherereadymsg_unpack(v)? +return i, unpacked +} +pub struct CVirtualHereShareDeviceMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +device_address string +has_device_address bool +} +pub fn (o &CVirtualHereShareDeviceMsg) pack() []byte { +mut res := []byte{} +if o.has_device_address { +res << vproto.pack_string_field(o.device_address, 1) +} + +return res +} + +pub fn cvirtualheresharedevicemsg_unpack(buf []byte) ?CVirtualHereShareDeviceMsg { +mut res := CVirtualHereShareDeviceMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_device_address = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.device_address = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cvirtualheresharedevicemsg() CVirtualHereShareDeviceMsg { +return CVirtualHereShareDeviceMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cvirtualheresharedevicemsg(o CVirtualHereShareDeviceMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cvirtualheresharedevicemsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CVirtualHereShareDeviceMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cvirtualheresharedevicemsg_unpack(v)? +return i, unpacked +} +pub struct CSetSpectatorModeMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +enabled bool +has_enabled bool +} +pub fn (o &CSetSpectatorModeMsg) pack() []byte { +mut res := []byte{} +if o.has_enabled { +res << vproto.pack_bool_field(o.enabled, 1) +} + +return res +} + +pub fn csetspectatormodemsg_unpack(buf []byte) ?CSetSpectatorModeMsg { +mut res := CSetSpectatorModeMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_enabled = true +ii, v := vproto.unpack_bool_field(cur_buf, tag_wiretype.wire_type)? +res.enabled = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csetspectatormodemsg() CSetSpectatorModeMsg { +return CSetSpectatorModeMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csetspectatormodemsg(o CSetSpectatorModeMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csetspectatormodemsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CSetSpectatorModeMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csetspectatormodemsg_unpack(v)? +return i, unpacked +} +pub struct CRemoteHIdmsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +data []byte +has_data bool +} +pub fn (o &CRemoteHIdmsg) pack() []byte { +mut res := []byte{} +if o.has_data { +res << vproto.pack_bytes_field(o.data, 1) +} + +return res +} + +pub fn cremotehidmsg_unpack(buf []byte) ?CRemoteHIdmsg { +mut res := CRemoteHIdmsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_data = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.data = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cremotehidmsg() CRemoteHIdmsg { +return CRemoteHIdmsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cremotehidmsg(o CRemoteHIdmsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cremotehidmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CRemoteHIdmsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cremotehidmsg_unpack(v)? +return i, unpacked +} +pub struct CTouchConfigActiveMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +revision u32 +has_revision bool +creator u64 +has_creator bool +} +pub fn (o &CTouchConfigActiveMsg) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_revision { +res << vproto.pack_uint32_field(o.revision, 2) +} + +if o.has_creator { +res << vproto.pack_uint64_field(o.creator, 3) +} + +return res +} + +pub fn ctouchconfigactivemsg_unpack(buf []byte) ?CTouchConfigActiveMsg { +mut res := CTouchConfigActiveMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_revision = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.revision = v +i = ii +} + +3 { +res.has_creator = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.creator = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctouchconfigactivemsg() CTouchConfigActiveMsg { +return CTouchConfigActiveMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctouchconfigactivemsg(o CTouchConfigActiveMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctouchconfigactivemsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CTouchConfigActiveMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctouchconfigactivemsg_unpack(v)? +return i, unpacked +} +pub struct CGetTouchConfigDataMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +} +pub fn (o &CGetTouchConfigDataMsg) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +return res +} + +pub fn cgettouchconfigdatamsg_unpack(buf []byte) ?CGetTouchConfigDataMsg { +mut res := CGetTouchConfigDataMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgettouchconfigdatamsg() CGetTouchConfigDataMsg { +return CGetTouchConfigDataMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgettouchconfigdatamsg(o CGetTouchConfigDataMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgettouchconfigdatamsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CGetTouchConfigDataMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgettouchconfigdatamsg_unpack(v)? +return i, unpacked +} +pub struct CSetTouchConfigDataMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +revision u32 +has_revision bool +data []byte +has_data bool +layout []byte +has_layout bool +creator u64 +has_creator bool +} +pub fn (o &CSetTouchConfigDataMsg) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_revision { +res << vproto.pack_uint32_field(o.revision, 2) +} + +if o.has_data { +res << vproto.pack_bytes_field(o.data, 3) +} + +if o.has_layout { +res << vproto.pack_bytes_field(o.layout, 4) +} + +if o.has_creator { +res << vproto.pack_uint64_field(o.creator, 5) +} + +return res +} + +pub fn csettouchconfigdatamsg_unpack(buf []byte) ?CSetTouchConfigDataMsg { +mut res := CSetTouchConfigDataMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_revision = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.revision = v +i = ii +} + +3 { +res.has_data = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.data = v +i = ii +} + +4 { +res.has_layout = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.layout = v +i = ii +} + +5 { +res.has_creator = true +ii, v := vproto.unpack_uint64_field(cur_buf, tag_wiretype.wire_type)? +res.creator = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csettouchconfigdatamsg() CSetTouchConfigDataMsg { +return CSetTouchConfigDataMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csettouchconfigdatamsg(o CSetTouchConfigDataMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csettouchconfigdatamsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CSetTouchConfigDataMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csettouchconfigdatamsg_unpack(v)? +return i, unpacked +} +pub struct CSaveTouchConfigLayoutMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +layout []byte +has_layout bool +} +pub fn (o &CSaveTouchConfigLayoutMsg) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_layout { +res << vproto.pack_bytes_field(o.layout, 4) +} + +return res +} + +pub fn csavetouchconfiglayoutmsg_unpack(buf []byte) ?CSaveTouchConfigLayoutMsg { +mut res := CSaveTouchConfigLayoutMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +4 { +res.has_layout = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.layout = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csavetouchconfiglayoutmsg() CSaveTouchConfigLayoutMsg { +return CSaveTouchConfigLayoutMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csavetouchconfiglayoutmsg(o CSaveTouchConfigLayoutMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csavetouchconfiglayoutmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CSaveTouchConfigLayoutMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csavetouchconfiglayoutmsg_unpack(v)? +return i, unpacked +} +pub struct CTouchActionSetActiveMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +actionset_id int +has_actionset_id bool +} +pub fn (o &CTouchActionSetActiveMsg) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_actionset_id { +res << vproto.pack_int32_field(o.actionset_id, 2) +} + +return res +} + +pub fn ctouchactionsetactivemsg_unpack(buf []byte) ?CTouchActionSetActiveMsg { +mut res := CTouchActionSetActiveMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_actionset_id = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.actionset_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctouchactionsetactivemsg() CTouchActionSetActiveMsg { +return CTouchActionSetActiveMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctouchactionsetactivemsg(o CTouchActionSetActiveMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctouchactionsetactivemsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CTouchActionSetActiveMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctouchactionsetactivemsg_unpack(v)? +return i, unpacked +} +pub struct CTouchActionSetLayerAddedMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +actionset_id int +has_actionset_id bool +} +pub fn (o &CTouchActionSetLayerAddedMsg) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_actionset_id { +res << vproto.pack_int32_field(o.actionset_id, 2) +} + +return res +} + +pub fn ctouchactionsetlayeraddedmsg_unpack(buf []byte) ?CTouchActionSetLayerAddedMsg { +mut res := CTouchActionSetLayerAddedMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_actionset_id = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.actionset_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctouchactionsetlayeraddedmsg() CTouchActionSetLayerAddedMsg { +return CTouchActionSetLayerAddedMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctouchactionsetlayeraddedmsg(o CTouchActionSetLayerAddedMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctouchactionsetlayeraddedmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CTouchActionSetLayerAddedMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctouchactionsetlayeraddedmsg_unpack(v)? +return i, unpacked +} +pub struct CTouchActionSetLayerRemovedMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +actionset_id int +has_actionset_id bool +} +pub fn (o &CTouchActionSetLayerRemovedMsg) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_actionset_id { +res << vproto.pack_int32_field(o.actionset_id, 2) +} + +return res +} + +pub fn ctouchactionsetlayerremovedmsg_unpack(buf []byte) ?CTouchActionSetLayerRemovedMsg { +mut res := CTouchActionSetLayerRemovedMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_actionset_id = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.actionset_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctouchactionsetlayerremovedmsg() CTouchActionSetLayerRemovedMsg { +return CTouchActionSetLayerRemovedMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctouchactionsetlayerremovedmsg(o CTouchActionSetLayerRemovedMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctouchactionsetlayerremovedmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CTouchActionSetLayerRemovedMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctouchactionsetlayerremovedmsg_unpack(v)? +return i, unpacked +} +pub struct CGetTouchIconDataMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +icon string +has_icon bool +} +pub fn (o &CGetTouchIconDataMsg) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_icon { +res << vproto.pack_string_field(o.icon, 2) +} + +return res +} + +pub fn cgettouchicondatamsg_unpack(buf []byte) ?CGetTouchIconDataMsg { +mut res := CGetTouchIconDataMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_icon = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.icon = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cgettouchicondatamsg() CGetTouchIconDataMsg { +return CGetTouchIconDataMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cgettouchicondatamsg(o CGetTouchIconDataMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cgettouchicondatamsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CGetTouchIconDataMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cgettouchicondatamsg_unpack(v)? +return i, unpacked +} +pub struct CSetTouchIconDataMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +appid u32 +has_appid bool +icon string +has_icon bool +data []byte +has_data bool +} +pub fn (o &CSetTouchIconDataMsg) pack() []byte { +mut res := []byte{} +if o.has_appid { +res << vproto.pack_uint32_field(o.appid, 1) +} + +if o.has_icon { +res << vproto.pack_string_field(o.icon, 2) +} + +if o.has_data { +res << vproto.pack_bytes_field(o.data, 3) +} + +return res +} + +pub fn csettouchicondatamsg_unpack(buf []byte) ?CSetTouchIconDataMsg { +mut res := CSetTouchIconDataMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_appid = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.appid = v +i = ii +} + +2 { +res.has_icon = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.icon = v +i = ii +} + +3 { +res.has_data = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.data = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_csettouchicondatamsg() CSetTouchIconDataMsg { +return CSetTouchIconDataMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_csettouchicondatamsg(o CSetTouchIconDataMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_csettouchicondatamsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CSetTouchIconDataMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := csettouchicondatamsg_unpack(v)? +return i, unpacked +} +pub struct CStreamDataLostMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +packets []u32 +} +pub fn (o &CStreamDataLostMsg) pack() []byte { +mut res := []byte{} +// [packed=false] +for _, x in o.packets { +res << vproto.pack_uint32_field(x, 1) +} + +return res +} + +pub fn cstreamdatalostmsg_unpack(buf []byte) ?CStreamDataLostMsg { +mut res := CStreamDataLostMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +// [packed=false] +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.packets << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstreamdatalostmsg() CStreamDataLostMsg { +return CStreamDataLostMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstreamdatalostmsg(o CStreamDataLostMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstreamdatalostmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CStreamDataLostMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstreamdatalostmsg_unpack(v)? +return i, unpacked +} +pub struct CAudioFormat { +mut: +unknown_fields []vproto.UnknownField +pub mut: +format EAudioFormat +frequency u32 +has_frequency bool +channels u32 +has_channels bool +} +pub fn (o &CAudioFormat) pack() []byte { +mut res := []byte{} +res << zzz_vproto_internal_pack_eaudioformat(o.format, 1) + +if o.has_frequency { +res << vproto.pack_uint32_field(o.frequency, 2) +} + +if o.has_channels { +res << vproto.pack_uint32_field(o.channels, 3) +} + +return res +} + +pub fn caudioformat_unpack(buf []byte) ?CAudioFormat { +mut res := CAudioFormat{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := zzz_vproto_internal_unpack_eaudioformat(cur_buf, tag_wiretype.wire_type)? +res.format = v +i = ii +} + +2 { +res.has_frequency = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.frequency = v +i = ii +} + +3 { +res.has_channels = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.channels = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_caudioformat() CAudioFormat { +return CAudioFormat{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_caudioformat(o CAudioFormat, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_caudioformat(buf []byte, tag_wiretype vproto.WireType) ?(int, CAudioFormat) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := caudioformat_unpack(v)? +return i, unpacked +} +pub struct CVideoFormat { +mut: +unknown_fields []vproto.UnknownField +pub mut: +format EVideoFormat +width u32 +has_width bool +height u32 +has_height bool +} +pub fn (o &CVideoFormat) pack() []byte { +mut res := []byte{} +res << zzz_vproto_internal_pack_evideoformat(o.format, 1) + +if o.has_width { +res << vproto.pack_uint32_field(o.width, 2) +} + +if o.has_height { +res << vproto.pack_uint32_field(o.height, 3) +} + +return res +} + +pub fn cvideoformat_unpack(buf []byte) ?CVideoFormat { +mut res := CVideoFormat{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := zzz_vproto_internal_unpack_evideoformat(cur_buf, tag_wiretype.wire_type)? +res.format = v +i = ii +} + +2 { +res.has_width = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.width = v +i = ii +} + +3 { +res.has_height = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.height = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cvideoformat() CVideoFormat { +return CVideoFormat{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cvideoformat(o CVideoFormat, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cvideoformat(buf []byte, tag_wiretype vproto.WireType) ?(int, CVideoFormat) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cvideoformat_unpack(v)? +return i, unpacked +} +pub struct CFrameEvent { +mut: +unknown_fields []vproto.UnknownField +pub mut: +event_id EStreamFrameEvent +timestamp u32 +} +pub fn (o &CFrameEvent) pack() []byte { +mut res := []byte{} +res << zzz_vproto_internal_pack_estreamframeevent(o.event_id, 1) + +res << vproto.pack_uint32_field(o.timestamp, 2) + +return res +} + +pub fn cframeevent_unpack(buf []byte) ?CFrameEvent { +mut res := CFrameEvent{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := zzz_vproto_internal_unpack_estreamframeevent(cur_buf, tag_wiretype.wire_type)? +res.event_id = v +i = ii +} + +2 { +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.timestamp = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cframeevent() CFrameEvent { +return CFrameEvent{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cframeevent(o CFrameEvent, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cframeevent(buf []byte, tag_wiretype vproto.WireType) ?(int, CFrameEvent) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cframeevent_unpack(v)? +return i, unpacked +} +pub struct CFrameStats { +mut: +unknown_fields []vproto.UnknownField +pub mut: +frame_id u32 +input_mark u32 +has_input_mark bool +events []CFrameEvent +result EStreamFrameResult +frame_start_delta f32 +has_frame_start_delta bool +frame_display_delta f32 +has_frame_display_delta bool +ping_time f32 +has_ping_time bool +server_bitrate f32 +has_server_bitrate bool +client_bitrate f32 +has_client_bitrate bool +link_bandwidth f32 +has_link_bandwidth bool +packet_loss f32 +has_packet_loss bool +frame_size u32 +has_frame_size bool +} +pub fn (o &CFrameStats) pack() []byte { +mut res := []byte{} +res << vproto.pack_uint32_field(o.frame_id, 1) + +if o.has_input_mark { +res << vproto.pack_uint32_field(o.input_mark, 2) +} + +// [packed=false] +for _, x in o.events { +res << zzz_vproto_internal_pack_cframeevent(x, 3) +} + +res << zzz_vproto_internal_pack_estreamframeresult(o.result, 4) + +if o.has_frame_start_delta { +res << vproto.pack_float_field(o.frame_start_delta, 5) +} + +if o.has_frame_display_delta { +res << vproto.pack_float_field(o.frame_display_delta, 6) +} + +if o.has_ping_time { +res << vproto.pack_float_field(o.ping_time, 7) +} + +if o.has_server_bitrate { +res << vproto.pack_float_field(o.server_bitrate, 8) +} + +if o.has_client_bitrate { +res << vproto.pack_float_field(o.client_bitrate, 9) +} + +if o.has_link_bandwidth { +res << vproto.pack_float_field(o.link_bandwidth, 10) +} + +if o.has_packet_loss { +res << vproto.pack_float_field(o.packet_loss, 11) +} + +if o.has_frame_size { +res << vproto.pack_uint32_field(o.frame_size, 12) +} + +return res +} + +pub fn cframestats_unpack(buf []byte) ?CFrameStats { +mut res := CFrameStats{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.frame_id = v +i = ii +} + +2 { +res.has_input_mark = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.input_mark = v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cframeevent(cur_buf, tag_wiretype.wire_type)? +res.events << v +i = ii +} + +4 { +ii, v := zzz_vproto_internal_unpack_estreamframeresult(cur_buf, tag_wiretype.wire_type)? +res.result = v +i = ii +} + +5 { +res.has_frame_start_delta = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.frame_start_delta = v +i = ii +} + +6 { +res.has_frame_display_delta = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.frame_display_delta = v +i = ii +} + +7 { +res.has_ping_time = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.ping_time = v +i = ii +} + +8 { +res.has_server_bitrate = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.server_bitrate = v +i = ii +} + +9 { +res.has_client_bitrate = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.client_bitrate = v +i = ii +} + +10 { +res.has_link_bandwidth = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.link_bandwidth = v +i = ii +} + +11 { +res.has_packet_loss = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.packet_loss = v +i = ii +} + +12 { +res.has_frame_size = true +ii, v := vproto.unpack_uint32_field(cur_buf, tag_wiretype.wire_type)? +res.frame_size = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cframestats() CFrameStats { +return CFrameStats{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cframestats(o CFrameStats, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cframestats(buf []byte, tag_wiretype vproto.WireType) ?(int, CFrameStats) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cframestats_unpack(v)? +return i, unpacked +} +pub struct CFrameStatAccumulatedValue { +mut: +unknown_fields []vproto.UnknownField +pub mut: +stat_type EFrameAccumulatedStat +count int +average f32 +stddev f32 +has_stddev bool +} +pub fn (o &CFrameStatAccumulatedValue) pack() []byte { +mut res := []byte{} +res << zzz_vproto_internal_pack_eframeaccumulatedstat(o.stat_type, 1) + +res << vproto.pack_int32_field(o.count, 2) + +res << vproto.pack_float_field(o.average, 3) + +if o.has_stddev { +res << vproto.pack_float_field(o.stddev, 4) +} + +return res +} + +pub fn cframestataccumulatedvalue_unpack(buf []byte) ?CFrameStatAccumulatedValue { +mut res := CFrameStatAccumulatedValue{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := zzz_vproto_internal_unpack_eframeaccumulatedstat(cur_buf, tag_wiretype.wire_type)? +res.stat_type = v +i = ii +} + +2 { +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.count = v +i = ii +} + +3 { +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.average = v +i = ii +} + +4 { +res.has_stddev = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.stddev = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cframestataccumulatedvalue() CFrameStatAccumulatedValue { +return CFrameStatAccumulatedValue{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cframestataccumulatedvalue(o CFrameStatAccumulatedValue, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cframestataccumulatedvalue(buf []byte, tag_wiretype vproto.WireType) ?(int, CFrameStatAccumulatedValue) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cframestataccumulatedvalue_unpack(v)? +return i, unpacked +} +pub struct CFrameStatsListMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +data_type EStreamingDataType +stats []CFrameStats +accumulated_stats []CFrameStatAccumulatedValue +latest_frame_id int +} +pub fn (o &CFrameStatsListMsg) pack() []byte { +mut res := []byte{} +res << zzz_vproto_internal_pack_estreamingdatatype(o.data_type, 1) + +// [packed=false] +for _, x in o.stats { +res << zzz_vproto_internal_pack_cframestats(x, 2) +} + +// [packed=false] +for _, x in o.accumulated_stats { +res << zzz_vproto_internal_pack_cframestataccumulatedvalue(x, 3) +} + +res << vproto.pack_int32_field(o.latest_frame_id, 4) + +return res +} + +pub fn cframestatslistmsg_unpack(buf []byte) ?CFrameStatsListMsg { +mut res := CFrameStatsListMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +ii, v := zzz_vproto_internal_unpack_estreamingdatatype(cur_buf, tag_wiretype.wire_type)? +res.data_type = v +i = ii +} + +2 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cframestats(cur_buf, tag_wiretype.wire_type)? +res.stats << v +i = ii +} + +3 { +// [packed=false] +ii, v := zzz_vproto_internal_unpack_cframestataccumulatedvalue(cur_buf, tag_wiretype.wire_type)? +res.accumulated_stats << v +i = ii +} + +4 { +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.latest_frame_id = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cframestatslistmsg() CFrameStatsListMsg { +return CFrameStatsListMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cframestatslistmsg(o CFrameStatsListMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cframestatslistmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CFrameStatsListMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cframestatslistmsg_unpack(v)? +return i, unpacked +} +pub struct CStreamingSessionStats { +mut: +unknown_fields []vproto.UnknownField +pub mut: +frame_loss_percentage f32 +has_frame_loss_percentage bool +average_network_time_ms f32 +has_average_network_time_ms bool +stddev_network_time_ms f32 +has_stddev_network_time_ms bool +} +pub fn (o &CStreamingSessionStats) pack() []byte { +mut res := []byte{} +if o.has_frame_loss_percentage { +res << vproto.pack_float_field(o.frame_loss_percentage, 1) +} + +if o.has_average_network_time_ms { +res << vproto.pack_float_field(o.average_network_time_ms, 2) +} + +if o.has_stddev_network_time_ms { +res << vproto.pack_float_field(o.stddev_network_time_ms, 3) +} + +return res +} + +pub fn cstreamingsessionstats_unpack(buf []byte) ?CStreamingSessionStats { +mut res := CStreamingSessionStats{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_frame_loss_percentage = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.frame_loss_percentage = v +i = ii +} + +2 { +res.has_average_network_time_ms = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.average_network_time_ms = v +i = ii +} + +3 { +res.has_stddev_network_time_ms = true +ii, v := vproto.unpack_float_field(cur_buf, tag_wiretype.wire_type)? +res.stddev_network_time_ms = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cstreamingsessionstats() CStreamingSessionStats { +return CStreamingSessionStats{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cstreamingsessionstats(o CStreamingSessionStats, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cstreamingsessionstats(buf []byte, tag_wiretype vproto.WireType) ?(int, CStreamingSessionStats) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cstreamingsessionstats_unpack(v)? +return i, unpacked +} +pub struct CDebugDumpMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +screenshot []byte +has_screenshot bool +} +pub fn (o &CDebugDumpMsg) pack() []byte { +mut res := []byte{} +if o.has_screenshot { +res << vproto.pack_bytes_field(o.screenshot, 1) +} + +return res +} + +pub fn cdebugdumpmsg_unpack(buf []byte) ?CDebugDumpMsg { +mut res := CDebugDumpMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_screenshot = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.screenshot = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cdebugdumpmsg() CDebugDumpMsg { +return CDebugDumpMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cdebugdumpmsg(o CDebugDumpMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cdebugdumpmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CDebugDumpMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cdebugdumpmsg_unpack(v)? +return i, unpacked +} +pub struct CLogMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +@type int +has_type bool +message string +has_message bool +} +pub fn (o &CLogMsg) pack() []byte { +mut res := []byte{} +if o.has_type { +res << vproto.pack_int32_field(o.@type, 1) +} + +if o.has_message { +res << vproto.pack_string_field(o.message, 2) +} + +return res +} + +pub fn clogmsg_unpack(buf []byte) ?CLogMsg { +mut res := CLogMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_type = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.@type = v +i = ii +} + +2 { +res.has_message = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.message = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_clogmsg() CLogMsg { +return CLogMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_clogmsg(o CLogMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_clogmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CLogMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := clogmsg_unpack(v)? +return i, unpacked +} +pub struct CLogUploadMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +@type ELogFileType +has_type bool +data []byte +has_data bool +} +pub fn (o &CLogUploadMsg) pack() []byte { +mut res := []byte{} +if o.has_type { +res << zzz_vproto_internal_pack_elogfiletype(o.@type, 1) +} + +if o.has_data { +res << vproto.pack_bytes_field(o.data, 3) +} + +return res +} + +pub fn cloguploadmsg_unpack(buf []byte) ?CLogUploadMsg { +mut res := CLogUploadMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_type = true +ii, v := zzz_vproto_internal_unpack_elogfiletype(cur_buf, tag_wiretype.wire_type)? +res.@type = v +i = ii +} + +3 { +res.has_data = true +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.data = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_cloguploadmsg() CLogUploadMsg { +return CLogUploadMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_cloguploadmsg(o CLogUploadMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_cloguploadmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CLogUploadMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := cloguploadmsg_unpack(v)? +return i, unpacked +} +pub struct CTransportSignalMsgWebRTcmessageCandidate { +mut: +unknown_fields []vproto.UnknownField +pub mut: +sdp_mid string +has_sdp_mid bool +sdp_mline_index int +has_sdp_mline_index bool +candidate string +has_candidate bool +} +pub fn (o &CTransportSignalMsgWebRTcmessageCandidate) pack() []byte { +mut res := []byte{} +if o.has_sdp_mid { +res << vproto.pack_string_field(o.sdp_mid, 1) +} + +if o.has_sdp_mline_index { +res << vproto.pack_int32_field(o.sdp_mline_index, 2) +} + +if o.has_candidate { +res << vproto.pack_string_field(o.candidate, 3) +} + +return res +} + +pub fn ctransportsignalmsgwebrtcmessagecandidate_unpack(buf []byte) ?CTransportSignalMsgWebRTcmessageCandidate { +mut res := CTransportSignalMsgWebRTcmessageCandidate{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_sdp_mid = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.sdp_mid = v +i = ii +} + +2 { +res.has_sdp_mline_index = true +ii, v := vproto.unpack_int32_field(cur_buf, tag_wiretype.wire_type)? +res.sdp_mline_index = v +i = ii +} + +3 { +res.has_candidate = true +ii, v := vproto.unpack_string_field(cur_buf, tag_wiretype.wire_type)? +res.candidate = v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctransportsignalmsgwebrtcmessagecandidate() CTransportSignalMsgWebRTcmessageCandidate { +return CTransportSignalMsgWebRTcmessageCandidate{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctransportsignalmsgwebrtcmessagecandidate(o CTransportSignalMsgWebRTcmessageCandidate, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctransportsignalmsgwebrtcmessagecandidate(buf []byte, tag_wiretype vproto.WireType) ?(int, CTransportSignalMsgWebRTcmessageCandidate) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctransportsignalmsgwebrtcmessagecandidate_unpack(v)? +return i, unpacked +} +pub struct CTransportSignalMsgWebRTcmessage { +mut: +unknown_fields []vproto.UnknownField +} +pub fn (o &CTransportSignalMsgWebRTcmessage) pack() []byte { +res := []byte{} +return res +} + +pub fn ctransportsignalmsgwebrtcmessage_unpack(buf []byte) ?CTransportSignalMsgWebRTcmessage { +res := CTransportSignalMsgWebRTcmessage{} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctransportsignalmsgwebrtcmessage() CTransportSignalMsgWebRTcmessage { +return CTransportSignalMsgWebRTcmessage{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctransportsignalmsgwebrtcmessage(o CTransportSignalMsgWebRTcmessage, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctransportsignalmsgwebrtcmessage(buf []byte, tag_wiretype vproto.WireType) ?(int, CTransportSignalMsgWebRTcmessage) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctransportsignalmsgwebrtcmessage_unpack(v)? +return i, unpacked +} +pub struct CTransportSignalMsg { +mut: +unknown_fields []vproto.UnknownField +pub mut: +webrtc CTransportSignalMsgWebRTcmessage +has_webrtc bool +sdr [][]byte +} +pub fn (o &CTransportSignalMsg) pack() []byte { +mut res := []byte{} +if o.has_webrtc { +res << zzz_vproto_internal_pack_ctransportsignalmsgwebrtcmessage(o.webrtc, 1) +} + +// [packed=false] +for _, x in o.sdr { +res << vproto.pack_bytes_field(x, 2) +} + +return res +} + +pub fn ctransportsignalmsg_unpack(buf []byte) ?CTransportSignalMsg { +mut res := CTransportSignalMsg{} +mut total := 0 + for total < buf.len { + mut i := 0 + buf_before_wire_type := buf[total..] + tag_wiretype := vproto.unpack_tag_wire_type(buf_before_wire_type) or { return error('malformed protobuf (couldnt parse tag & wire type)') } + cur_buf := buf_before_wire_type[tag_wiretype.consumed..] + match tag_wiretype.tag { +1 { +res.has_webrtc = true +ii, v := zzz_vproto_internal_unpack_ctransportsignalmsgwebrtcmessage(cur_buf, tag_wiretype.wire_type)? +res.webrtc = v +i = ii +} + +2 { +// [packed=false] +ii, v := vproto.unpack_bytes_field(cur_buf, tag_wiretype.wire_type)? +res.sdr << v +i = ii +} + +else { +ii, v := vproto.unpack_unknown_field(cur_buf, tag_wiretype.wire_type) +res.unknown_fields << vproto.UnknownField{tag_wiretype.wire_type, tag_wiretype.tag, v} +i = ii +} +} +if i == 0 { return error('malformed protobuf (didnt unpack a field)') } +total += tag_wiretype.consumed + i +} +return res +} + +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_new_ctransportsignalmsg() CTransportSignalMsg { +return CTransportSignalMsg{} +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_pack_ctransportsignalmsg(o CTransportSignalMsg, num u32) []byte { +return vproto.pack_message_field(o.pack(), num) +} +// FOR INTERNAL USE ONLY +pub fn zzz_vproto_internal_unpack_ctransportsignalmsg(buf []byte, tag_wiretype vproto.WireType) ?(int, CTransportSignalMsg) { +i, v := vproto.unpack_message_field(buf, tag_wiretype)? +mut unpacked := ctransportsignalmsg_unpack(v)? +return i, unpacked +} diff --git a/resources/protobufs b/resources/protobufs new file mode 160000 index 0000000..0b4d61a --- /dev/null +++ b/resources/protobufs @@ -0,0 +1 @@ +Subproject commit 0b4d61a15f6a0c00d90bf47c9e7e462199456e93 diff --git a/steamclient.v b/steamclient.v new file mode 100644 index 0000000..b751e54 --- /dev/null +++ b/steamclient.v @@ -0,0 +1,243 @@ +module vapor + +import encoding.base64 +import proto + +struct TcpHeader { +mut: + size int + magic u32 +} + +struct Packet { + header TcpHeader +mut: + body []byte +} + +struct Message { + msg Msg + source u64 + target u64 + body []byte +} + +// TODO +// type FillFn = fn (mut body []byte)? + +struct SteamClient { +mut: + cm_addr string + client TcpClient + handlers []MsgHandler + session_id u32 + encryption &EncryptionHandler +} + +pub fn new_steamclient() &SteamClient { + s := &SteamClient { + encryption: &EncryptionHandler{} + } + + s.handlers << s + s.handlers << s.encryption + + for h in s.handlers { + h.initialise(mut s) + } + + return s +} + +pub fn (_ SteamClient) initialise(mut s SteamClient) ? { +} + +pub fn (mut s SteamClient) connect() ? { + cm := hardcoded_cm() + println('connecting to $cm') + s.client = new_tcp_client(cm)? +} + +pub fn (mut s SteamClient) connected() bool { + return s.encryption.encrypted == true +} + +pub fn (mut s SteamClient) frame() ? { + for { + if p := s.read_packet() { + if msg := s.process_packet(p) { + s.dispatch(msg)? + } + } else { + break + } + } +} + +fn (mut s SteamClient) read_packet() ?Packet { + mut header := TcpHeader {} + tcpclient_read(mut s.client, mut header, sizeof(TcpHeader)) + + mut body := []byte{ len: header.size } + s.client.read_into(body)? + + return s.encryption.decrypt_packet(Packet {header body}) +} + +fn (mut s SteamClient) fake_packet(body []byte) ? { + decrypted := s.encryption.decrypt_packet(Packet { TcpHeader {size: body.len magic: 0} body})? + s.process_packet(decrypted)? +} + +fn (mut s SteamClient) process_packet(p Packet) ?Message { + base_header := &MsgBaseHeader(p.body.data) + is_proto, msg := base_header.decompose() + + println('$msg $is_proto') + + mut source_job_id := u64(0) + mut target_job_id := u64(0) + mut msg_body := array{} + + if !is_proto { + match msg { + .channel_encrypt_request, + .channel_encrypt_result { + full_header := &MsgHeader(p.body.data) + source_job_id = full_header.source_job_id + target_job_id = full_header.target_job_id + msg_body = p.body[sizeof(MsgHeader)..] + } + else {} + } + } else { + full_header := &MsgHdrProtobuf(p.body.data) + header := proto.cmsgprotobufheader_unpack(p.body[sizeof(MsgHdrProtobuf)..int(sizeof(MsgHdrProtobuf))+full_header.header_length])? + println('$header') + + match msg { + .client_log_on_response { + // TODO remove + sliced := p.body[int(sizeof(MsgHdrProtobuf))+full_header.header_length..] + message := proto.cmsgclientlogonresponse_unpack(sliced)? + + println('$message') + println('$message.eresult') + } + + else { + println('unknown message') + } + } + } + + return Message { + msg + source_job_id + target_job_id + msg_body + } +} + +fn (mut s SteamClient) dispatch(m Message) ? { + for h in s.handlers { + h.handle_msg(m) + } +} + +fn (mut s SteamClient) handle_msg(m Message) ? { +} + +fn (mut s SteamClient) write_packet(mut data []byte) ? { + mut p := Packet { + TcpHeader { data.len } + data + } + p = s.encryption.encrypt_packet(p)? + mut body := p.body + val := byte(0) + // prepend 8 bytes for packet header + // TODO careful this doesnt do what we want at all + // and just reads random crap off of the stack!!!! + body.prepend_many(val, int(sizeof(TcpHeader))) + + mut packet_header := &TcpHeader(body.data) + packet_header.size = p.header.size + packet_header.magic = 0x31305456 // VT01 + + s.client.write(body)? +} + +fn (mut s SteamClient) write_non_protobuf_message(m Message) ? { + if m.msg != .channel_encrypt_response { + panic('This should only ever be called for channel_encrypt_response') + } + // Prepend 20 bytes for msg header + mut body := m.body + val := byte(0) + body.prepend_many(val, int(sizeof(MsgHeader))) + + mut message_header := &MsgHeader(body.data) + message_header.msg = m.msg + message_header.source_job_id = ~0 + message_header.target_job_id = ~0 + + s.write_packet(body)? +} + +fn (mut s SteamClient) write_message(m Message) ? { + mut header := proto.CMsgProtoBufHeader{} + + header.has_steamid = true + header.steamid = 76561197960265728 + + header.has_client_sessionid = true + header.client_sessionid = int(s.session_id) + + if m.target != 0 { + header.has_jobid_target = true + header.jobid_target = m.target + } + + packed_header := header.pack() + + mut full_message := []byte{len: int(sizeof(MsgHdrProtobuf))} + mut proto_header := &MsgHdrProtobuf(full_message.data) + proto_header.msg = m.msg.make_proto() + proto_header.header_length = packed_header.len + + // put the proto header after the normal header + full_message << packed_header + full_message << m.body + + s.write_packet(full_message) +} + +pub fn steamclient_write_message(mut s SteamClient, job u64, m Msg, body &Packable, size u32) ? { + s.write_message(Message { + target: job + msg: m + body: body.pack() + }) +} + +pub fn (mut s SteamClient) logon(username, password string) ? { + mut logon_message := proto.CMsgClientLogon{} + + logon_message.has_protocol_version = true + logon_message.protocol_version = 65575 + + logon_message.has_account_name = true + logon_message.account_name = username + + logon_message.has_password = true + logon_message.password = password + + logon_message.has_cell_id = true + logon_message.cell_id = 4 + + packed := logon_message.pack() + println('${base64.encode(tos(packed.data, packed.len))}') + + steamclient_write_message(mut s, 0, .client_logon, &logon_message, sizeof(proto.CMsgClientLogon)) +} \ No newline at end of file diff --git a/steamfriends.v b/steamfriends.v new file mode 100644 index 0000000..d85a9b7 --- /dev/null +++ b/steamfriends.v @@ -0,0 +1,12 @@ +module vapor + +struct SteamFriends { +} + +pub fn (mut s SteamFriends) initialise() ? { + +} + +pub fn (mut s SteamFriends) handle_msg(mut m Message) ? { + +} \ No newline at end of file diff --git a/tcpclient.v b/tcpclient.v new file mode 100644 index 0000000..cb40d47 --- /dev/null +++ b/tcpclient.v @@ -0,0 +1,55 @@ +module vapor + +import emily33901.net + +import time + +// TcpClient is a basic wrapper around a tcp connection +// right now it is implemented with loose functions until +// our good friend Joe C gets round to adding methods :) +struct TcpClient { + c net.TcpConn +} + +pub fn new_tcp_client(addr string) ?TcpClient { + mut c := net.dial_tcp(addr)? + + // set a timeout so we dont choke the CPU when there is nothing to read + c.set_read_timeout(5 * time.second) + + return TcpClient{c} +} + +fn (mut c TcpClient) read_into(b []byte) ? { + len := b.len + mut read := 0 + for read < len { + read += c.c.read_into(mut b[read..]) or { + 0 + } + } +} + +pub fn (mut c TcpClient) write(data []byte) ? { + c.c.write(data)? +} + +pub fn tcpclient_read(mut c TcpClient, mut v T, size u32) ? { + arr := array {data: v len: int(size) element_size: 1} + c.read_into(arr)? +} + +// pub fn (mut c TcpClient) read(mut v T) ? { +// arr := array {data: &v len: sizeof(T) element_size: 1} +// c.read_into(mut arr)? +// } + +pub fn tcpclient_write(mut c TcpClient, mut v T, size u32) ? { + arr := array {data: v len: int(size) element_size: 1} + c.write(arr)? +} + +// pub fn (mut c TcpClient) write(v T) ? { +// arr := array {data: &v len: sizeof(T) element_size: 1} +// c.c.write(arr)? +// } \ No newline at end of file diff --git a/testbed/main.v b/testbed/main.v new file mode 100644 index 0000000..0850f91 --- /dev/null +++ b/testbed/main.v @@ -0,0 +1,46 @@ +module main + +import time + +import emily33901.vapor + +import json +import os + +struct Secrets { + username string + password string +} + +fn pump (mut s vapor.SteamClient) { + s.connect() + + for { + s.frame() or { + panic('$errcode $err') + } + time.sleep_ms(1) + } +} + +fn main() { + mut s := vapor.new_steamclient() + + go pump(mut s) + + // wait for encrypted + for !s.connected() { + println('waiting for steam...') + time.sleep_ms(1000) + } + + ssecrets := os.read_file('secrets.json')? + secrets := json.decode(Secrets, ssecrets)? + + s.logon(secrets.username, secrets.password)? + + for { + // wait for stuff to happen i guess + time.sleep_ms(1000) + } +} diff --git a/testbed/secrets_default.json b/testbed/secrets_default.json new file mode 100644 index 0000000..714a17b --- /dev/null +++ b/testbed/secrets_default.json @@ -0,0 +1,4 @@ +{ + "username": "", + "password": "" +} \ No newline at end of file diff --git a/tools/protogen.v b/tools/protogen.v new file mode 100644 index 0000000..25b47af --- /dev/null +++ b/tools/protogen.v @@ -0,0 +1,74 @@ +module main + +import emily33901.vproto.compiler + +// This file does a lot of what vproto.v does +// but this time its just automated for a reason + +import os +import v.table +import v.parser +import v.pref +import v.fmt +import v.ast + +fn format_file(path string) { + table := table.new_table() + ast_file := parser.parse_file(path, table, .parse_comments, &pref.Preferences{}, &ast.Scope{ + parent: 0 + }) + + result := fmt.fmt(ast_file, table, false) + + os.write_file(path, result) +} + +fn main() { + println('Generating protobufs...') + + exe_file := find_abs_path_of_executable(os.executable())? + exe_path := exe_file.all_before_last(os.path_separator) + println('exe path is $exe_path') + + protobufs_location := os.real_path('$exe_path/../resources/protobufs/steam/') + out_folder := os.real_path('$exe_path/../proto/') + + mut paths := os.ls(protobufs_location)? + paths << os.real_path('$protobufs_location/../google/protobuf/descriptor.proto') + + imports := ['$protobufs_location', os.real_path('$protobufs_location/..')] + println('imports are $protobufs_location') + + for file_name in paths { + // check for the google descriptor protobuf + // which is the only absolute name here + path := if file_name.contains(os.path_separator) { + file_name + } else { + '$protobufs_location/$file_name' + } + + println('$path') + + if os.is_dir(path) { continue } + + if !os.is_dir(out_folder) { + println('creating folder $out_folder ...') + os.mkdir(out_folder) + } + + // TODO do we really need to validate here aswell? + // seems slightly unnecessary since we know that the + // steam protos are well formed + mut p := compiler.new_parser(false, imports) + mut f := p.parse_file(path, 'proto') + p.validate() + + mut g := compiler.new_gen(p) + filename := os.real_path(f.filename).all_after_last(os.path_separator).all_before_last('.') + '_pb.v' + out_path := os.join_path(os.real_path(out_folder), filename) + os.write_file(out_path, g.gen_file_text(f)) + // TODO reenable + // format_file(out_path) + } +} \ No newline at end of file diff --git a/v.mod b/v.mod new file mode 100644 index 0000000..de4e714 --- /dev/null +++ b/v.mod @@ -0,0 +1,5 @@ +Module { + name: 'vapor', + description: 'V steamkit implementation', + dependencies: ['emily33901.net', 'emily33901.tomcrypt', 'emily33901.vproto'] +} \ No newline at end of file