Hearthhack/src/main/proto/bnet/protocol/protocol.proto

syntax = "proto2";
package bnet.protocol;

// Proto extractor compiled unit - https://github.com/HearthSim/proto-extractor

option java_package = "com.alterdekim";
option java_outer_classname = "Protocol";

// ref: PegasusUtil.RpcHeader
message RpcHeader {
	required uint64 type = 1;
	optional uint64 retry_count = 2 [default = 0];
}

// ref: PegasusUtil.RpcMessage
message RpcMessage {
	required RpcHeader rpc_header = 1;
	optional bytes message_body = 2;
}

// ref: bnet.protocol.attribute.Attribute
message Attribute {
	required string name = 1;
	required Variant value = 2;
}

// ref: bnet.protocol.attribute.AttributeFilter
message AttributeFilter {
	// ref: bnet.protocol.attribute.AttributeFilter/Types/Operation
	enum Operation {
		MATCH_NONE = 0;
		MATCH_ANY = 1;
		MATCH_ALL = 2;
		MATCH_ALL_MOST_SPECIFIC = 3;
	}

	required Operation op = 1;
	repeated Attribute attribute = 2;
}

// ref: bnet.protocol.attribute.Variant
message Variant {
	optional bool bool_value = 2;
	optional int64 int_value = 3;
	optional double float_value = 4;
	optional string string_value = 5;
	optional bytes blob_value = 6;
	optional bytes message_value = 7;
	optional string fourcc_value = 8;
	optional uint64 uint_value = 9;
	optional bnet.protocol.EntityId entityid_value = 10;
}



// ref: bnet.protocol.AccountInfo
message AccountInfo {
	optional bool account_paid = 1 [default = false];
	optional fixed32 country_id = 2 [default = 0];
	optional string battle_tag = 3;
	optional bool manual_review = 4 [default = false];
}

// ref: bnet.protocol.Address
message Address {
	required string address = 1;
	optional uint32 port = 2;
}

// ref: bnet.protocol.ContentHandle
message ContentHandle {
	required fixed32 region = 1;
	required fixed32 usage = 2;
	required bytes hash = 3;
	optional string proto_url = 4;
}

// ref: bnet.protocol.EntityId
message EntityId {
	required fixed64 high = 1;
	required fixed64 low = 2;
}

// ref: bnet.protocol.ErrorInfo
message ErrorInfo {
	required ObjectAddress object_address = 1;
	required uint32 status = 2;
	required uint32 service_hash = 3;
	required uint32 method_id = 4;
}

// ref: bnet.protocol.Header
message Header {
	required uint32 service_id = 1;
	optional uint32 method_id = 2;
	required uint32 token = 3;
	optional uint64 object_id = 4 [default = 0];
	optional uint32 size = 5 [default = 0];
	optional uint32 status = 6 [default = 0];
	repeated ErrorInfo error = 7;
	optional uint64 timeout = 8;
}

// ref: bnet.protocol.Identity
message Identity {
	optional EntityId account_id = 1;
	optional EntityId game_account_id = 2;
}

// ref: bnet.protocol.NoData
message NoData {
}

// ref: bnet.protocol.NORESPONSE
message NORESPONSE {
}

// ref: bnet.protocol.ObjectAddress
message ObjectAddress {
	required ProcessId host = 1;
	optional uint64 object_id = 2 [default = 0];
}

// ref: bnet.protocol.Path
message Path {
	repeated uint32 ordinal = 1 [packed=true];
}

// ref: bnet.protocol.Privilege
message Privilege {
	required string name = 1;
	required uint32 value = 2;
}

// ref: bnet.protocol.ProcessId
message ProcessId {
	required uint32 label = 1;
	required uint32 epoch = 2;
}

// ref: bnet.protocol.Role
message Role {
	required uint32 id = 1;
	required string name = 2;
	repeated string privilege = 3;
	repeated uint32 assignable_role = 4 [packed=true];
	optional bool required = 5 [default = false];
	optional bool unique = 6 [default = false];
	optional uint32 relegation_role = 7;
	repeated bnet.protocol.Attribute attribute = 8;
}

// ref: bnet.protocol.RoleSet
message RoleSet {
	required string program = 1;
	required string service = 2;
	optional string subtype = 3 [default = "default"];
	repeated Role role = 4;
	repeated uint32 default_role = 5 [packed=true];
	optional int32 max_members = 6;
	repeated bnet.protocol.Attribute attribute = 7;
}

// ref: bnet.protocol.RoleSetConfig
message RoleSetConfig {
	repeated Privilege privilege = 1;
	required RoleSet role_set = 2;
}

/////////////// protocol end

// ref: bnet.protocol.account.AccountBlob
message AccountBlob {
	required fixed32 id = 2;
	required uint32 region = 3;
	repeated string email = 4;
	required uint64 flags = 5;
	optional uint64 secure_release = 6;
	optional uint64 whitelist_start = 7;
	optional uint64 whitelist_end = 8;
	required string full_name = 10;
	repeated AccountLicense licenses = 20;
	repeated AccountCredential credentials = 21;
	repeated GameAccountLink account_links = 22;
	optional string battle_tag = 23;
	optional fixed32 default_currency = 25;
	optional uint32 legal_region = 26;
	optional fixed32 legal_locale = 27;
	required uint64 cache_expiration = 30;
	optional ParentalControlInfo parental_control_info = 31;
	optional string country = 32;
	optional uint32 preferred_region = 33;
}

// ref: bnet.protocol.account.AccountBlobList
message AccountBlobList {
	repeated AccountBlob blob = 1;
}

// ref: bnet.protocol.account.AccountCredential
message AccountCredential {
	required uint32 id = 1;
	optional bytes data = 2;
}

// ref: bnet.protocol.account.AccountFieldOptions
message AccountFieldOptions {
	optional bool all_f1elds = 1; // clashes
	optional bool field_account_level_info = 2;
	optional bool field_privacy_info = 3;
	optional bool field_parental_control_info = 4;
	optional bool field_game_level_info = 6;
	optional bool field_game_status = 7;
	optional bool field_game_accounts = 8;
}

// ref: bnet.protocol.account.AccountFieldTags
message AccountFieldTags {
	optional fixed32 account_level_info_tag = 2;
	optional fixed32 privacy_info_tag = 3;
	optional fixed32 parental_control_info_tag = 4;
	repeated ProgramTag game_level_info_tags = 7;
	repeated ProgramTag game_status_tags = 9;
	repeated RegionTag game_account_tags = 11;
}

// ref: bnet.protocol.account.AccountId
message AccountId {
	required fixed32 id = 1;
}

// ref: bnet.protocol.account.AccountLevelInfo
message AccountLevelInfo {
	repeated AccountLicense licenses = 3;
	optional fixed32 default_currency = 4;
	optional string country = 5;
	optional uint32 preferred_region = 6;
}

// ref: bnet.protocol.account.AccountLicense
message AccountLicense {
	required uint32 id = 1;
	optional uint64 expires = 2;
}

// ref: bnet.protocol.account.AccountReference
message AccountReference {
	optional fixed32 id = 1;
	optional string email = 2;
	optional GameAccountHandle handle = 3;
	optional string battle_tag = 4;
	optional uint32 region = 10 [default = 0];
}

// ref: bnet.protocol.account.AccountServiceConfig
message AccountServiceConfig {
	repeated AccountServiceRegion region = 1;
}

// ref: bnet.protocol.account.AccountServiceRegion
message AccountServiceRegion {
	required uint32 id = 1;
	required string shard = 2;
}

// ref: bnet.protocol.account.AccountState
message AccountState {
	optional AccountLevelInfo account_level_info = 1;
	optional PrivacyInfo privacy_info = 2;
	optional ParentalControlInfo parental_control_info = 3;
	repeated GameLevelInfo game_level_info = 5;
	repeated GameStatus game_status = 6;
	repeated GameAccountList game_accounts = 7;
}

// ref: bnet.protocol.account.AccountStateNotification
message AccountStateNotification {
	optional AccountState state = 1;
	optional uint64 subscriber_id = 2;
	optional AccountFieldTags account_tags = 3;
	optional bool subscription_completed = 4;
}

// ref: bnet.protocol.account.AccountStateTagged
message AccountStateTagged {
	optional AccountState account_state = 1;
	optional AccountFieldTags tags = 2;
}

// ref: bnet.protocol.account.CacheExpireRequest
message CacheExpireRequest {
	repeated AccountId account = 1;
	repeated GameAccountHandle game_account = 2;
	repeated string email = 3;
}

// ref: bnet.protocol.account.CAIS
message CAIS {
	optional uint32 played_minutes = 1;
	optional uint32 rested_minutes = 2;
	optional uint64 last_heard_time = 3;
}

// ref: bnet.protocol.account.CreateGameAccountRequest
message CreateGameAccountRequest {
	optional AccountId account = 1;
	optional uint32 region = 2;
	optional fixed32 program = 3;
	optional uint32 realm_permissions = 4 [default = 1];
}

// ref: bnet.protocol.account.CredentialUpdateRequest
message CredentialUpdateRequest {
	required AccountId account = 1;
	repeated AccountCredential old_credentials = 2;
	repeated AccountCredential new_credentials = 3;
	optional uint32 region = 4;
}

// ref: bnet.protocol.account.CredentialUpdateResponse
message CredentialUpdateResponse {
}

// ref: bnet.protocol.account.CurrencyRestriction
message CurrencyRestriction {
	required string currency = 1;
	required string authenticator_cap = 2;
	required string soft_cap = 3;
}

// ref: bnet.protocol.account.FlagUpdateRequest
message FlagUpdateRequest {
	required AccountId account = 1;
	optional uint32 region = 2;
	required uint64 flag = 3;
	required bool active = 4;
}

// ref: bnet.protocol.account.FlagUpdateResponse
message FlagUpdateResponse {
}

// ref: bnet.protocol.account.ForwardCacheExpireRequest
message ForwardCacheExpireRequest {
	optional bnet.protocol.EntityId entity_id = 1;
}

// ref: bnet.protocol.account.GameAccountBlob
message GameAccountBlob {
	required GameAccountHandle game_account = 1;
	optional string name = 2 [default = ""];
	optional uint32 realm_permissions = 3 [default = 0];
	required uint32 status = 4;
	optional uint64 flags = 5 [default = 0];
	optional uint32 billing_flags = 6 [default = 0];
	required uint64 cache_expiration = 7;
	optional uint64 subscription_expiration = 10;
	optional uint32 units_remaining = 11;
	optional uint64 status_expiration = 12;
	optional uint32 box_level = 13;
	optional uint64 box_level_expiration = 14;
	repeated AccountLicense licenses = 20;
}

// ref: bnet.protocol.account.GameAccountBlobList
message GameAccountBlobList {
	repeated GameAccountBlob blob = 1;
}

// ref: bnet.protocol.account.GameAccountFieldOptions
message GameAccountFieldOptions {
	optional bool all_f1elds = 1; // clashes
	optional bool field_game_level_info = 2;
	optional bool field_game_time_info = 3;
	optional bool field_game_status = 4;
}

// ref: bnet.protocol.account.GameAccountFieldTags
message GameAccountFieldTags {
	optional fixed32 game_level_info_tag = 2;
	optional fixed32 game_time_info_tag = 3;
	optional fixed32 game_status_tag = 4;
}

// ref: bnet.protocol.account.GameAccountHandle
message GameAccountHandle {
	required fixed32 id = 1;
	required fixed32 program = 2;
	required uint32 region = 3;
}

// ref: bnet.protocol.account.GameAccountLink
message GameAccountLink {
	required GameAccountHandle game_account = 1;
	required string name = 2;
}

// ref: bnet.protocol.account.GameAccountList
message GameAccountList {
	optional uint32 region = 3;
	repeated GameAccountHandle handle = 4;
}

// ref: bnet.protocol.account.GameAccountNotification
message GameAccountNotification {
	repeated GameAccountList region_delta = 1;
	optional uint64 subscriber_id = 2;
	optional AccountFieldTags account_tags = 3;
}

// ref: bnet.protocol.account.GameAccountSessionNotification
message GameAccountSessionNotification {
	optional GameAccountHandle game_account = 1;
	optional GameSessionUpdateInfo session_info = 2;
}

// ref: bnet.protocol.account.GameAccountState
message GameAccountState {
	optional GameLevelInfo game_level_info = 1;
	optional GameTimeInfo game_time_info = 2;
	optional GameStatus game_status = 3;
}

// ref: bnet.protocol.account.GameAccountStateNotification
message GameAccountStateNotification {
	optional GameAccountState state = 1;
	optional uint64 subscriber_id = 2;
	optional GameAccountFieldTags game_account_tags = 3;
	optional bool subscription_completed = 4;
}

// ref: bnet.protocol.account.GameAccountStateTagged
message GameAccountStateTagged {
	optional GameAccountState game_account_state = 1;
	optional GameAccountFieldTags game_account_tags = 2;
}

// ref: bnet.protocol.account.GameLevelInfo
message GameLevelInfo {
	optional bool is_starter_edition = 3;
	optional bool is_trial = 4;
	optional bool is_lifetime = 5;
	optional bool is_restricted = 6;
	optional bool is_beta = 7;
	optional string name = 8;
	optional fixed32 program = 9;
	repeated AccountLicense licenses = 10;
	optional uint32 realm_permissions = 11;
}

// ref: bnet.protocol.account.GameSessionInfo
message GameSessionInfo {
	optional uint32 start_time = 3;
	optional GameSessionLocation location = 4;
	optional bool has_benefactor = 5;
	optional bool is_using_igr = 6;
	optional bool parental_controls_active = 7;
}

// ref: bnet.protocol.account.GameSessionLocation
message GameSessionLocation {
	optional string ip_address = 1;
	optional uint32 country = 2;
	optional string city = 3;
}

// ref: bnet.protocol.account.GameSessionUpdateInfo
message GameSessionUpdateInfo {
	optional CAIS cais = 8;
}

// ref: bnet.protocol.account.GameStatus
message GameStatus {
	optional bool is_suspended = 4;
	optional bool is_banned = 5;
	optional uint64 suspension_expires = 6;
	optional fixed32 program = 7;
}

// ref: bnet.protocol.account.GameTimeInfo
message GameTimeInfo {
	optional bool is_unlimited_play_time = 3;
	optional uint64 play_time_expires = 5;
	optional bool is_subscription = 6;
	optional bool is_recurring_subscription = 7;
}

// ref: bnet.protocol.account.GameTimeRemainingInfo
message GameTimeRemainingInfo {
	optional uint32 minutes_remaining = 1;
	optional uint32 parental_daily_minutes_remaining = 2;
	optional uint32 parental_weekly_minutes_remaining = 3;
}

// ref: bnet.protocol.account.GetAccountRequest
message GetAccountRequest {
	optional AccountReference ref = 1;
	optional bool fetch_all = 10 [default = false];
	optional bool fetch_blob = 11 [default = false];
	optional bool fetch_id = 12 [default = false];
	optional bool fetch_email = 13 [default = false];
	optional bool fetch_battle_tag = 14 [default = false];
	optional bool fetch_full_name = 15 [default = false];
	optional bool fetch_links = 16 [default = false];
	optional bool fetch_parental_controls = 17 [default = false];
}

// ref: bnet.protocol.account.GetAccountResponse
message GetAccountResponse {
	optional AccountBlob blob = 11;
	optional AccountId id = 12;
	repeated string email = 13;
	optional string battle_tag = 14;
	optional string full_name = 15;
	repeated GameAccountLink links = 16;
	optional ParentalControlInfo parental_control_info = 17;
}

// ref: bnet.protocol.account.GetAccountStateRequest
message GetAccountStateRequest {
	optional bnet.protocol.EntityId entity_id = 1;
	optional uint32 program = 2;
	optional uint32 region = 3;
	optional AccountFieldOptions options = 10;
	optional AccountFieldTags tags = 11;
}

// ref: bnet.protocol.account.GetAccountStateResponse
message GetAccountStateResponse {
	optional AccountState state = 1;
	optional AccountFieldTags tags = 2;
}

// ref: bnet.protocol.account.GetCAISInfoRequest
message GetCAISInfoRequest {
	optional bnet.protocol.EntityId entity_id = 1;
}

// ref: bnet.protocol.account.GetCAISInfoResponse
message GetCAISInfoResponse {
	optional CAIS cais_info = 1;
}

// ref: bnet.protocol.account.GetEBalanceRequest
message GetEBalanceRequest {
	required AccountId account_id = 1;
	required string currency = 2;
	optional uint32 currency_home_region = 3;
}

// ref: bnet.protocol.account.GetEBalanceResponse
message GetEBalanceResponse {
	optional string balance = 1;
}

// ref: bnet.protocol.account.GetEBalanceRestrictionsRequest
message GetEBalanceRestrictionsRequest {
	optional uint32 currency_home_region = 1;
}

// ref: bnet.protocol.account.GetEBalanceRestrictionsResponse
message GetEBalanceRestrictionsResponse {
	repeated CurrencyRestriction currency_restrictions = 1;
}

// ref: bnet.protocol.account.GetGameAccountStateRequest
message GetGameAccountStateRequest {
	optional bnet.protocol.EntityId account_id = 1;
	optional bnet.protocol.EntityId game_account_id = 2;
	optional GameAccountFieldOptions options = 10;
	optional GameAccountFieldTags tags = 11;
}

// ref: bnet.protocol.account.GetGameAccountStateResponse
message GetGameAccountStateResponse {
	optional GameAccountState state = 1;
	optional GameAccountFieldTags tags = 2;
}

// ref: bnet.protocol.account.GetGameSessionInfoRequest
message GetGameSessionInfoRequest {
	optional bnet.protocol.EntityId entity_id = 1;
}

// ref: bnet.protocol.account.GetGameSessionInfoResponse
message GetGameSessionInfoResponse {
	optional GameSessionInfo session_info = 2;
}

// ref: bnet.protocol.account.GetGameTimeRemainingInfoRequest
message GetGameTimeRemainingInfoRequest {
	optional bnet.protocol.EntityId game_account_id = 1;
	optional bnet.protocol.EntityId account_id = 2;
}

// ref: bnet.protocol.account.GetGameTimeRemainingInfoResponse
message GetGameTimeRemainingInfoResponse {
	optional GameTimeRemainingInfo game_time_remaining_info = 1;
}

// ref: bnet.protocol.account.GetLicensesRequest
message GetLicensesRequest {
	optional bnet.protocol.EntityId target_id = 1;
	optional bool get_account_licenses = 2;
	optional bool get_game_account_licenses = 3;
	optional bool get_dynamic_account_licenses = 4;
	optional fixed32 program_id = 5;
	optional bool exclude_unknown_program = 6 [default = false];
}

// ref: bnet.protocol.account.GetLicensesResponse
message GetLicensesResponse {
	repeated AccountLicense licenses = 1;
}

// ref: bnet.protocol.account.GetWalletListRequest
message GetWalletListRequest {
	required AccountId account_id = 1;
	optional bool refresh = 2 [default = false];
}

// ref: bnet.protocol.account.GetWalletListResponse
message GetWalletListResponse {
	repeated Wallet wallets = 1;
}

// ref: bnet.protocol.account.IsIgrAddressRequest
message IsIgrAddressRequest {
	optional string client_address = 1;
	optional uint32 region = 2;
}

// ref: bnet.protocol.account.ParentalControlInfo
message ParentalControlInfo {
	optional string timezone = 3;
	optional uint32 minutes_per_day = 4;
	optional uint32 minutes_per_week = 5;
	optional bool can_receive_voice = 6;
	optional bool can_send_voice = 7;
	repeated bool play_schedule = 8;
}

// ref: bnet.protocol.account.PrivacyInfo
message PrivacyInfo {
	// ref: bnet.protocol.account.PrivacyInfo/Types/GameInfoPrivacy
	enum GameInfoPrivacy {
		PRIVACY_ME = 0;
		PRIVACY_FRIENDS = 1;
		PRIVACY_EVERYONE = 2;
	}

	optional bool is_using_rid = 3;
	optional bool is_real_id_visible_for_view_friends = 4;
	optional bool is_hidden_from_friend_finder = 5;
	optional GameInfoPrivacy game_info_privacy = 6 [default = PRIVACY_FRIENDS];
}

// ref: bnet.protocol.account.ProgramTag
message ProgramTag {
	optional fixed32 program = 1;
	optional fixed32 tag = 2;
}

// ref: bnet.protocol.account.RegionTag
message RegionTag {
	optional fixed32 region = 1;
	optional fixed32 tag = 2;
}

// ref: bnet.protocol.account.SubscriberReference
message SubscriberReference {
	optional uint64 object_id = 1 [default = 0];
	optional bnet.protocol.EntityId entity_id = 2;
	optional AccountFieldOptions account_options = 3;
	optional AccountFieldTags account_tags = 4;
	optional GameAccountFieldOptions game_account_options = 5;
	optional GameAccountFieldTags game_account_tags = 6;
}

// ref: bnet.protocol.account.SubscriptionUpdateRequest
message SubscriptionUpdateRequest {
	repeated SubscriberReference ref = 2;
}

// ref: bnet.protocol.account.SubscriptionUpdateResponse
message SubscriptionUpdateResponse {
	repeated SubscriberReference ref = 1;
}

// ref: bnet.protocol.account.Wallet
message Wallet {
	required uint32 region = 1;
	required uint64 wallet_id = 2;
	required uint32 wallet_type = 3;
	optional string description = 4;
	required uint32 country_id = 5;
	optional string state = 6;
	optional string city = 7;
	optional string postal_code = 8;
	optional bytes payment_info = 9;
	optional string bin = 10;
	optional string locale_id = 11;
	optional string street = 12;
	optional string first_name = 13;
	optional string last_name = 14;
	optional uint64 birth_date = 15;
}

// ref: bnet.protocol.account.Wallets
message Wallets {
	repeated Wallet wallets = 1;
}


///////////////


// ref: bnet.protocol.authentication.AccountSettingsNotification
message AccountSettingsNotification {
	repeated bnet.protocol.AccountLicense licenses = 1;
	optional bool is_using_rid = 2;
	optional bool is_playing_from_igr = 3;
	optional bool can_receive_voice = 4;
	optional bool can_send_voice = 5;
}

// ref: bnet.protocol.authentication.GameAccountSelectedRequest
message GameAccountSelectedRequest {
	required uint32 result = 1;
	optional bnet.protocol.EntityId game_account = 2;
}

// ref: bnet.protocol.authentication.GenerateSSOTokenRequest
message GenerateSSOTokenRequest {
	optional fixed32 program = 1;
}

// ref: bnet.protocol.authentication.GenerateSSOTokenResponse
message GenerateSSOTokenResponse {
	optional bytes sso_id = 1;
	optional bytes sso_secret = 2;
}

// ref: bnet.protocol.authentication.LogonQueueUpdateRequest
message LogonQueueUpdateRequest {
	required uint32 position = 1;
	required uint64 estimated_time = 2;
	required uint64 eta_deviation_in_sec = 3;
}

// ref: bnet.protocol.authentication.LogonRequest
message LogonRequest {
	optional string program = 1;
	optional string platform = 2;
	optional string locale = 3;
	optional string email = 4;
	optional string version = 5;
	optional int32 application_version = 6;
	optional bool public_computer = 7;
	optional bytes sso_id = 8;
	optional bool disconnect_on_cookie_fail = 9 [default = false];
	optional bool allow_logon_queue_notifications = 10 [default = false];
	optional bool web_client_verification = 11 [default = false];
	optional bytes cached_web_credentials = 12;
	optional string user_agent = 14;
}

// ref: bnet.protocol.authentication.LogonResult
message LogonResult {
	required uint32 error_code = 1;
	optional bnet.protocol.EntityId account = 2;
	repeated bnet.protocol.EntityId game_account = 3;
	optional string email = 4;
	repeated uint32 available_region = 5;
	optional uint32 connected_region = 6;
	optional string battle_tag = 7;
	optional string geoip_country = 8;
}

// ref: bnet.protocol.authentication.LogonUpdateRequest
message LogonUpdateRequest {
	required uint32 error_code = 1;
}

// ref: bnet.protocol.authentication.MemModuleLoadRequest
message MemModuleLoadRequest {
	required bnet.protocol.ContentHandle handle = 1;
	required bytes key = 2;
	required bytes input = 3;
}

// ref: bnet.protocol.authentication.MemModuleLoadResponse
message MemModuleLoadResponse {
	required bytes data = 1;
}

// ref: bnet.protocol.authentication.ModuleLoadRequest
message ModuleLoadRequest {
	required bnet.protocol.ContentHandle module_handle = 1;
	optional bytes message = 2;
}

// ref: bnet.protocol.authentication.ModuleMessageRequest
message ModuleMessageRequest {
	required int32 module_id = 1;
	optional bytes message = 2;
}

// ref: bnet.protocol.authentication.ModuleNotification
message ModuleNotification {
	optional int32 module_id = 2;
	optional uint32 result = 3;
}

// ref: bnet.protocol.authentication.SelectGameAccountRequest
message SelectGameAccountRequest {
	required bnet.protocol.EntityId game_account = 1;
}

// ref: bnet.protocol.authentication.ServerStateChangeRequest
message ServerStateChangeRequest {
	required uint32 state = 1;
	required uint64 event_time = 2;
}

// ref: bnet.protocol.authentication.VerifyWebCredentialsRequest
message VerifyWebCredentialsRequest {
	optional bytes web_credentials = 1;
}

// ref: bnet.protocol.authentication.VersionInfo
message VersionInfo {
	optional uint32 number = 1;
	optional string patch = 2;
	optional bool is_optional = 3;
	optional uint64 kick_time = 4;
}

// ref: bnet.protocol.authentication.VersionInfoNotification
message VersionInfoNotification {
	optional VersionInfo version_info = 1;
}

////////////////


// ref: bnet.protocol.challenge.Challenge
message Challenge {
	required fixed32 type = 1;
	optional string info = 2;
	optional string answer = 3;
	optional uint32 retries = 4;
}

// ref: bnet.protocol.challenge.ChallengeAnsweredRequest
message ChallengeAnsweredRequest {
	required string answer = 1;
	optional bytes data = 2;
	optional uint32 id = 3;
}

// ref: bnet.protocol.challenge.ChallengeAnsweredResponse
message ChallengeAnsweredResponse {
	optional bytes data = 1;
	optional bool do_retry = 2;
	optional bool record_not_found = 3;
}

// ref: bnet.protocol.challenge.ChallengeCancelledRequest
message ChallengeCancelledRequest {
	optional uint32 id = 1;
}

// ref: bnet.protocol.challenge.ChallengeExternalRequest
message ChallengeExternalRequest {
	optional string request_token = 1;
	optional string payload_type = 2;
	optional bytes payload = 3;
}

// ref: bnet.protocol.challenge.ChallengeExternalResult
message ChallengeExternalResult {
	optional string request_token = 1;
	optional bool passed = 2 [default = true];
}

// ref: bnet.protocol.challenge.ChallengePickedRequest
message ChallengePickedRequest {
	required fixed32 challenge = 1;
	optional uint32 id = 2;
	optional bool new_challenge_protocol = 3 [default = false];
}

// ref: bnet.protocol.challenge.ChallengePickedResponse
message ChallengePickedResponse {
	optional bytes data = 1;
}

// ref: bnet.protocol.challenge.ChallengeResultRequest
message ChallengeResultRequest {
	optional uint32 id = 1;
	optional fixed32 type = 2;
	optional uint32 error_id = 3;
	optional bytes answer = 4;
}

// ref: bnet.protocol.challenge.ChallengeUserRequest
message ChallengeUserRequest {
	repeated Challenge challenges = 1;
	required fixed32 context = 2;
	optional uint32 id = 3;
	optional uint64 deadline = 4;
	repeated bnet.protocol.Attribute attributes = 5;
	optional bnet.protocol.EntityId game_account_id = 6;
}

// ref: bnet.protocol.challenge.SendChallengeToUserRequest
message SendChallengeToUserRequest {
	optional bnet.protocol.ProcessId peer_id = 1;
	optional bnet.protocol.EntityId game_account_id = 2;
	repeated Challenge challenges = 3;
	required fixed32 context = 4;
	optional uint64 timeout = 5;
	repeated bnet.protocol.Attribute attributes = 6;
}

// ref: bnet.protocol.challenge.SendChallengeToUserResponse
message SendChallengeToUserResponse {
	optional uint32 id = 1;
}

////// chat

// ref: bnet.protocol.chat.ChannelState
message ChannelState {
	optional string identity = 1;
	optional fixed32 program = 2;
	optional fixed32 locale = 3;
	optional bool public = 4 [default = false];
	optional uint32 bucket_index = 5;
}

///////////////////

// ref: bnet.protocol.config.RPCMeterConfig
message RPCMeterConfig {
	repeated RPCMethodConfig method = 1;
	optional uint32 income_per_second = 2 [default = 1];
	optional uint32 initial_balance = 3;
	optional uint32 cap_balance = 4;
	optional float startup_period = 5 [default = 0];
}

// ref: bnet.protocol.config.RPCMethodConfig
message RPCMethodConfig {
	optional string service_name = 1;
	optional string method_name = 2;
	optional uint32 fixed_call_cost = 3 [default = 1];
	optional uint32 fixed_packet_size = 4 [default = 0];
	optional float variable_multiplier = 5 [default = 0];
	optional float multiplier = 6 [default = 1];
	optional uint32 rate_limit_count = 7;
	optional uint32 rate_limit_seconds = 8;
	optional uint32 max_packet_size = 9;
	optional uint32 max_encoded_size = 10;
	optional float timeout = 11;
}

///////////////// conn

// ref: bnet.protocol.connection.BindRequest
message BindRequest {
	repeated fixed32 imported_service_hash = 1;
	repeated BoundService exported_service = 2;
}

// ref: bnet.protocol.connection.BindResponse
message BindResponse {
	repeated uint32 imported_service_id = 1 [packed=true];
}

// ref: bnet.protocol.connection.BoundService
message BoundService {
	required fixed32 hash = 1;
	required uint32 id = 2;
}

// ref: bnet.protocol.connection.ConnectionMeteringContentHandles
message ConnectionMeteringContentHandles {
	repeated bnet.protocol.ContentHandle content_handle = 1;
}

// ref: bnet.protocol.connection.ConnectRequest
message ConnectRequest {
	optional bnet.protocol.ProcessId client_id = 1;
	optional BindRequest bind_request = 2;
}

// ref: bnet.protocol.connection.ConnectResponse
message ConnectResponse {
	required bnet.protocol.ProcessId server_id = 1;
	optional bnet.protocol.ProcessId client_id = 2;
	optional uint32 bind_result = 3;
	optional BindResponse bind_response = 4;
	optional ConnectionMeteringContentHandles content_handle_array = 5;
	optional uint64 server_time = 6;
}

// ref: bnet.protocol.connection.DisconnectNotification
message DisconnectNotification {
	required uint32 error_code = 1;
	optional string reason = 2;
}

// ref: bnet.protocol.connection.DisconnectRequest
message DisconnectRequest {
	required uint32 error_code = 1;
}

// ref: bnet.protocol.connection.EchoRequest
message EchoRequest {
	optional fixed64 time = 1;
	optional bool network_only = 2 [default = false];
	optional bytes payload = 3;
}

// ref: bnet.protocol.connection.EchoResponse
message EchoResponse {
	optional fixed64 time = 1;
	optional bytes payload = 2;
}

// ref: bnet.protocol.connection.EncryptRequest
message EncryptRequest {
}

////// game_utilities

// ref: bnet.protocol.game_utilities.ClientRequest
message ClientRequest {
	repeated bnet.protocol.Attribute attribute = 1;
	optional bnet.protocol.ProcessId host = 2;
	optional bnet.protocol.EntityId bnet_account_id = 3;
	optional bnet.protocol.EntityId game_account_id = 4;
}

// ref: bnet.protocol.game_utilities.ClientResponse
message ClientResponse {
	repeated bnet.protocol.Attribute attribute = 1;
}

// ref: bnet.protocol.game_utilities.GameAccountOfflineNotification
message GameAccountOfflineNotification {
	required bnet.protocol.EntityId game_account_id = 1;
	optional bnet.protocol.ProcessId host = 2;
}

// ref: bnet.protocol.game_utilities.GameAccountOnlineNotification
message GameAccountOnlineNotification {
	required bnet.protocol.EntityId game_account_id = 1;
	optional bnet.protocol.ProcessId host = 2;
}

// ref: bnet.protocol.game_utilities.GetPlayerVariablesRequest
message GetPlayerVariablesRequest {
	repeated PlayerVariables player_variables = 1;
	optional bnet.protocol.ProcessId host = 2;
}

// ref: bnet.protocol.game_utilities.GetPlayerVariablesResponse
message GetPlayerVariablesResponse {
	repeated PlayerVariables player_variables = 1;
}

// ref: bnet.protocol.game_utilities.PlayerVariables
message PlayerVariables {
	required bnet.protocol.Identity identity = 1;
	optional double rating = 2;
	repeated bnet.protocol.Attribute attribute = 3;
}

// ref: bnet.protocol.game_utilities.PresenceChannelCreatedRequest
message PresenceChannelCreatedRequest {
	required bnet.protocol.EntityId id = 1;
	optional bnet.protocol.EntityId game_account_id = 3;
	optional bnet.protocol.EntityId bnet_account_id = 4;
	optional bnet.protocol.ProcessId host = 5;
}

// ref: bnet.protocol.game_utilities.ServerRequest
message ServerRequest {
	repeated bnet.protocol.Attribute attribute = 1;
	required fixed32 program = 2;
	optional bnet.protocol.ProcessId host = 3;
}

// ref: bnet.protocol.game_utilities.ServerResponse
message ServerResponse {
	repeated bnet.protocol.Attribute attribute = 1;
}



// ref: bnet.protocol.notification.FindClientRequest
message FindClientRequest {
	required bnet.protocol.EntityId entity_id = 1;
}

// ref: bnet.protocol.notification.FindClientResponse
message FindClientResponse {
	required uint32 label = 1;
	optional bnet.protocol.ProcessId client_process_id = 2;
}

// ref: bnet.protocol.notification.Notification
message Notification {
	optional bnet.protocol.EntityId sender_id = 1;
	required bnet.protocol.EntityId target_id = 2;
	required string type = 3;
	repeated bnet.protocol.Attribute attribute = 4;
	optional bnet.protocol.EntityId sender_account_id = 5;
	optional bnet.protocol.EntityId target_account_id = 6;
	optional string sender_battle_tag = 7;
}

// ref: bnet.protocol.notification.RegisterClientRequest
message RegisterClientRequest {
	required bnet.protocol.EntityId entity_id = 1;
}

// ref: bnet.protocol.notification.UnregisterClientRequest
message UnregisterClientRequest {
	required bnet.protocol.EntityId entity_id = 1;
}

//

// ref: bnet.protocol.presence.ChannelState
message PresenceChannelState {
	optional bnet.protocol.EntityId entity_id = 1;
	repeated FieldOperation field_operation = 2;
	optional bool healing = 3 [default = false];
}

// ref: bnet.protocol.presence.Field
message Field {
	required FieldKey key = 1;
	required bnet.protocol.Variant value = 2;
}

// ref: bnet.protocol.presence.FieldKey
message FieldKey {
	required uint32 program = 1;
	required uint32 group = 2;
	required uint32 field = 3;
	optional uint64 index = 4 [default = 0];
}

// ref: bnet.protocol.presence.FieldOperation
message FieldOperation {
	// ref: bnet.protocol.presence.FieldOperation/Types/OperationType
	enum OperationType {
		SET = 0;
		CLEAR = 1;
	}

	required Field field = 1;
	optional OperationType operation = 2 [default = SET];
}

// ref: bnet.protocol.presence.OwnershipRequest
message OwnershipRequest {
	required bnet.protocol.EntityId entity_id = 1;
	optional bool release_ownership = 2 [default = false];
}

// ref: bnet.protocol.presence.QueryRequest
message QueryRequest {
	required bnet.protocol.EntityId entity_id = 1;
	repeated FieldKey key = 2;
}

// ref: bnet.protocol.presence.QueryResponse
message QueryResponse {
	repeated Field field = 2;
}

// ref: bnet.protocol.presence.RichPresence
message RichPresence {
	required fixed32 program_id = 1;
	required fixed32 stream_id = 2;
	required uint32 index = 3;
}

// ref: bnet.protocol.presence.SubscribeNotificationRequest
message SubscribeNotificationRequest {
	required bnet.protocol.EntityId entity_id = 1;
}

// ref: bnet.protocol.presence.SubscribeRequest
message SubscribeRequest {
	optional bnet.protocol.EntityId agent_id = 1;
	required bnet.protocol.EntityId entity_id = 2;
	required uint64 object_id = 3;
	repeated fixed32 program_id = 4;
}

// ref: bnet.protocol.presence.UnsubscribeRequest
message UnsubscribeRequest {
	optional bnet.protocol.EntityId agent_id = 1;
	required bnet.protocol.EntityId entity_id = 2;
}

// ref: bnet.protocol.presence.UpdateRequest
message UpdateRequest {
	required bnet.protocol.EntityId entity_id = 1;
	repeated FieldOperation field_operation = 2;
}

// PresenceChannelState

// ref: bnet.protocol.profanity.WordFilter
message WordFilter {
	required string type = 1;
	required string regex = 2;
}

// ref: bnet.protocol.profanity.WordFilters
message WordFilters {
	repeated WordFilter filters = 1;
}


// ref: bnet.protocol.resources.ContentHandleRequest
message ContentHandleRequest {
	required fixed32 program_id = 1;
	required fixed32 stream_id = 2;
	optional fixed32 locale = 3 [default = 1701729619];
}

/////////


// ref: bnet.protocol.server_pool.GetLoadRequest
message GetLoadRequest {
}

// ref: bnet.protocol.server_pool.PoolStateRequest
message PoolStateRequest {
}

// ref: bnet.protocol.server_pool.PoolStateResponse
message PoolStateResponse {
	repeated ServerInfo info = 1;
}

// ref: bnet.protocol.server_pool.ServerInfo
message ServerInfo {
	required bnet.protocol.ProcessId host = 1;
	optional bool replace = 2 [default = false];
	optional ServerState state = 3;
	repeated bnet.protocol.Attribute attribute = 4;
	optional fixed32 program_id = 5;
}

// ref: bnet.protocol.server_pool.ServerState
message ServerState {
	optional float current_load = 1 [default = 1];
	optional uint32 game_count = 2 [default = 0];
	optional uint32 player_count = 3 [default = 0];
}

/////////////

// ref: bnet.protocol.friends.AssignRoleRequest
message AssignRoleRequest {
	optional bnet.protocol.EntityId agent_id = 1;
	required bnet.protocol.EntityId target_id = 2;
	repeated int32 role = 3;
}

// ref: bnet.protocol.friends.Friend
message Friend {
	required bnet.protocol.EntityId id = 1;
	repeated bnet.protocol.Attribute attribute = 2;
	repeated uint32 role = 3 [packed=true];
	optional uint64 privileges = 4 [default = 0];
	optional uint64 attributes_epoch = 5;
	optional string full_name = 6;
	optional string battle_tag = 7;
}

// ref: bnet.protocol.friends.FriendInvitation
message FriendInvitation {
	optional bool first_received = 1 [default = false];
	repeated uint32 role = 2 [packed=true];
}

// ref: bnet.protocol.friends.FriendInvitationParams
message FriendInvitationParams {
	optional string target_email = 1;
	optional string target_battle_tag = 2;
	optional string inviter_battle_tag = 3;
	optional string inviter_full_name = 4;
	optional string invitee_display_name = 5;
	repeated uint32 role = 6 [packed=true];
}

// ref: bnet.protocol.friends.FriendNotification
message FriendNotification {
	required Friend target = 1;
	optional bnet.protocol.EntityId game_account_id = 2;
}

// ref: bnet.protocol.friends.GenericFriendRequest
message GenericFriendRequest {
	optional bnet.protocol.EntityId agent_id = 1;
	required bnet.protocol.EntityId target_id = 2;
}

// ref: bnet.protocol.friends.GenericFriendResponse
message GenericFriendResponse {
	optional Friend target_friend = 1;
}

// ref: bnet.protocol.friends.InvitationNotification
message InvitationNotification {
	required bnet.protocol.Invitation invitation = 1;
	optional bnet.protocol.EntityId game_account_id = 2;
	optional uint32 reason = 3 [default = 0];
}

// ref: bnet.protocol.friends.SubscribeToFriendsRequest
message SubscribeToFriendsRequest {
	optional bnet.protocol.EntityId agent_id = 1;
	required uint64 object_id = 2;
}

// ref: bnet.protocol.friends.SubscribeToFriendsResponse
message SubscribeToFriendsResponse {
	optional uint32 max_friends = 1;
	optional uint32 max_received_invitations = 2;
	optional uint32 max_sent_invitations = 3;
	repeated bnet.protocol.Role role = 4;
	repeated Friend friends = 5;
	repeated bnet.protocol.Invitation sent_invitations = 6;
	repeated bnet.protocol.Invitation received_invitations = 7;
}

// ref: bnet.protocol.friends.UnsubscribeToFriendsRequest
message UnsubscribeToFriendsRequest {
	optional bnet.protocol.EntityId agent_id = 1;
	optional uint64 object_id = 2;
}

// ref: bnet.protocol.friends.UpdateFriendStateNotification
message UpdateFriendStateNotification {
	required Friend changed_friend = 1;
	optional bnet.protocol.EntityId game_account_id = 2;
}

// ref: bnet.protocol.friends.UpdateFriendStateRequest
message UpdateFriendStateRequest {
	optional bnet.protocol.EntityId agent_id = 1;
	required bnet.protocol.EntityId target_id = 2;
	repeated bnet.protocol.Attribute attribute = 3;
	optional uint64 attributes_epoch = 4;
}

// ref: bnet.protocol.friends.ViewFriendsRequest
message ViewFriendsRequest {
	optional bnet.protocol.EntityId agent_id = 1;
	required bnet.protocol.EntityId target_id = 2;
	repeated uint32 role = 3 [packed=true];
}

// ref: bnet.protocol.friends.ViewFriendsResponse
message ViewFriendsResponse {
	repeated Friend friends = 1;
}


//


// ref: bnet.protocol.invitation.GenericRequest
message GenericRequest {
	optional bnet.protocol.EntityId agent_id = 1;
	optional bnet.protocol.EntityId target_id = 2;
	required fixed64 invitation_id = 3;
	optional string invitee_name = 4;
	optional string inviter_name = 5;
	repeated uint32 previous_role = 6 [packed=true];
	repeated uint32 desired_role = 7 [packed=true];
	optional uint32 reason = 8;
}

// ref: bnet.protocol.invitation.Invitation
message Invitation {
	required fixed64 id = 1;
	required bnet.protocol.Identity inviter_identity = 2;
	required bnet.protocol.Identity invitee_identity = 3;
	optional string inviter_name = 4;
	optional string invitee_name = 5;
	optional string invitation_message = 6;
	optional uint64 creation_time = 7;
	optional uint64 expiration_time = 8;
	optional bnet.protocol.FriendInvitation friend_invite = 103;
	optional bnet.protocol.ChannelInvitation channel_invitation = 105;
}

// ref: bnet.protocol.invitation.InvitationParams
message InvitationParams {
	optional string invitation_message = 1;
	optional uint64 expiration_time = 2 [default = 0];
	optional bnet.protocol.FriendInvitationParams friend_params = 103;
	optional bnet.protocol.ChannelInvitationParams channel_params = 105;
}

// ref: bnet.protocol.invitation.InvitationTarget
message InvitationTarget {
	optional bnet.protocol.Identity identity = 1;
	optional string email = 2;
	optional string battle_tag = 3;
}

// ref: bnet.protocol.invitation.SendInvitationRequest
message SendInvitationRequest {
	optional bnet.protocol.Identity agent_identity = 1;
	required bnet.protocol.EntityId target_id = 2;
	required InvitationParams params = 3;
	optional bnet.protocol.AccountInfo agent_info = 4;
	optional InvitationTarget target = 5;
}

// ref: bnet.protocol.invitation.SendInvitationResponse
message SendInvitationResponse {
	optional Invitation invitation = 2;
}

// ref: bnet.protocol.invitation.Suggestion
message Suggestion {
	optional bnet.protocol.EntityId channel_id = 1;
	required bnet.protocol.EntityId suggester_id = 2;
	required bnet.protocol.EntityId suggestee_id = 3;
	optional string suggester_name = 4;
	optional string suggestee_name = 5;
	optional bnet.protocol.EntityId suggester_account_id = 6;
}

// ref: bnet.protocol.invitation.UpdateInvitationRequest
message UpdateInvitationRequest {
	optional bnet.protocol.Identity agent_identity = 1;
	required fixed64 invitation_id = 2;
	required InvitationParams params = 3;
}

// ref: bnet.protocol.game_master.CancelGameEntryRequest
message CancelGameEntryRequest {
	required fixed64 request_id = 1;
	optional fixed64 factory_id = 2;
	repeated Player player = 3;
}

// ref: bnet.protocol.game_master.ChangeGameRequest
message ChangeGameRequest {
	required GameHandle game_handle = 1;
	optional bool open = 2;
	repeated bnet.protocol.Attribute attribute = 3;
	optional bool replace = 4 [default = false];
}

// ref: bnet.protocol.game_master.ConnectInfo
message ConnectInfo {
	required bnet.protocol.EntityId member_id = 1;
	required string host = 2;
	required int32 port = 3;
	optional bytes token = 4;
	repeated bnet.protocol.Attribute attribute = 5;
}

// ref: bnet.protocol.game_master.FactoryUpdateNotification
message FactoryUpdateNotification {
	// ref: bnet.protocol.game_master.FactoryUpdateNotification/Types/Operation
	enum Operation {
		ADD = 1;
		REMOVE = 2;
		CHANGE = 3;
	}

	required Operation op = 1;
	required GameFactoryDescription description = 2;
	optional fixed32 program_id = 3;
}

// ref: bnet.protocol.game_master.FindGameRequest
message FindGameRequest {
	repeated Player player = 1;
	optional fixed64 factory_id = 2;
	optional GameProperties properties = 3;
	optional uint64 object_id = 4;
	optional fixed64 request_id = 5;
	optional bool advanced_notification = 6 [default = false];
}

// ref: bnet.protocol.game_master.FindGameResponse
message FindGameResponse {
	optional fixed64 request_id = 1;
	optional fixed64 factory_id = 2;
	optional bool queued = 3 [default = false];
}

// ref: bnet.protocol.game_master.GameEndedNotification
message GameEndedNotification {
	required GameHandle game_handle = 1;
	optional uint32 reason = 2 [default = 0];
}

// ref: bnet.protocol.game_master.GameFactoryDescription
message GameFactoryDescription {
	required fixed64 id = 1;
	optional string name = 2;
	repeated bnet.protocol.Attribute attribute = 3;
	repeated GameStatsBucket stats_bucket = 4;
	optional fixed64 unseeded_id = 5 [default = 0];
	optional bool allow_queueing = 6 [default = true];
}

// ref: bnet.protocol.game_master.GameFoundNotification
message GameFoundNotification {
	required fixed64 request_id = 1;
	optional uint32 error_code = 2 [default = 0];
	optional GameHandle game_handle = 3;
	repeated ConnectInfo connect_info = 4;
}

// ref: bnet.protocol.game_master.GameHandle
message GameHandle {
	required fixed64 factory_id = 1;
	required bnet.protocol.EntityId game_id = 2;
}

// ref: bnet.protocol.game_master.GameProperties
message GameProperties {
	repeated bnet.protocol.Attribute creation_attributes = 1;
	optional bnet.protocol.AttributeFilter filter = 2;
	optional bool create = 3 [default = false];
	optional bool open = 4 [default = true];
	optional fixed32 program_id = 5;
}

// ref: bnet.protocol.game_master.GameStatsBucket
message GameStatsBucket {
	optional float bucket_min = 1 [default = 0];
	optional float bucket_max = 2 [default = 4.294967E+09];
	optional uint32 wait_milliseconds = 3 [default = 0];
	optional uint32 games_per_hour = 4 [default = 0];
	optional uint32 active_games = 5 [default = 0];
	optional uint32 active_players = 6 [default = 0];
	optional uint32 forming_games = 7 [default = 0];
	optional uint32 waiting_players = 8 [default = 0];
	optional uint32 open_joinable_games = 9 [default = 0];
	optional uint32 players_in_open_joinable_games = 10 [default = 0];
	optional uint32 open_games_total = 11 [default = 0];
	optional uint32 players_in_open_games_total = 12 [default = 0];
}

// ref: bnet.protocol.game_master.GetFactoryInfoRequest
message GetFactoryInfoRequest {
	required fixed64 factory_id = 1;
}

// ref: bnet.protocol.game_master.GetFactoryInfoResponse
message GetFactoryInfoResponse {
	repeated bnet.protocol.Attribute attribute = 1;
	repeated GameStatsBucket stats_bucket = 2;
}

// ref: bnet.protocol.game_master.GetGameStatsRequest
message GetGameStatsRequest {
	required fixed64 factory_id = 1;
	required bnet.protocol.AttributeFilter filter = 2;
}

// ref: bnet.protocol.game_master.GetGameStatsResponse
message GetGameStatsResponse {
	repeated GameStatsBucket stats_bucket = 1;
}

// ref: bnet.protocol.game_master.JoinGameRequest
message JoinGameRequest {
	required GameHandle game_handle = 1;
	repeated Player player = 2;
	optional bool advanced_notification = 3 [default = false];
}

// ref: bnet.protocol.game_master.JoinGameResponse
message JoinGameResponse {
	optional fixed64 request_id = 1;
	optional bool queued = 2 [default = false];
	repeated ConnectInfo connect_info = 3;
}

// ref: bnet.protocol.game_master.ListFactoriesRequest
message ListFactoriesRequest {
	required bnet.protocol.AttributeFilter filter = 1;
	optional uint32 start_index = 2 [default = 0];
	optional uint32 max_results = 3 [default = 100];
}

// ref: bnet.protocol.game_master.ListFactoriesResponse
message ListFactoriesResponse {
	repeated GameFactoryDescription description = 1;
	optional uint32 total_results = 2;
}

// ref: bnet.protocol.game_master.Player
message Player {
	optional bnet.protocol.Identity identity = 1;
	repeated bnet.protocol.Attribute attribute = 2;
}

// ref: bnet.protocol.game_master.PlayerLeftNotification
message PlayerLeftNotification {
	required GameHandle game_handle = 1;
	required bnet.protocol.EntityId member_id = 2;
	optional uint32 reason = 3 [default = 1];
}

// ref: bnet.protocol.game_master.RegisterServerRequest
message RegisterServerRequest {
	repeated bnet.protocol.Attribute attribute = 1;
	optional bnet.protocol.ServerState state = 2;
	required fixed32 program_id = 3;
}

// ref: bnet.protocol.game_master.RegisterUtilitiesRequest
message RegisterUtilitiesRequest {
	repeated bnet.protocol.Attribute attribute = 1;
	optional bnet.protocol.ServerState state = 2;
	required fixed32 program_id = 3;
}

// ref: bnet.protocol.game_master.SubscribeRequest
message MasterSubscribeRequest {
	required uint64 object_id = 1;
}

// ref: bnet.protocol.game_master.SubscribeResponse
message SubscribeResponse {
	optional uint64 subscription_id = 1;
}

// ref: bnet.protocol.game_master.UnregisterServerRequest
message UnregisterServerRequest {
}

// ref: bnet.protocol.game_master.UnregisterUtilitiesRequest
message UnregisterUtilitiesRequest {
}

// ref: bnet.protocol.game_master.UnsubscribeRequest
message MasterUnsubscribeRequest {
	required uint64 subscription_id = 1;
}

// ref: bnet.protocol.channel.AddMemberRequest
message AddMemberRequest {
	optional bnet.protocol.EntityId agent_id = 1;
	required bnet.protocol.Identity member_identity = 2;
	required MemberState member_state = 3;
	required uint64 object_id = 4;
	optional bool subscribe = 5 [default = true];
}

// ref: bnet.protocol.channel.AddNotification
message AddNotification {
	optional Member self = 1;
	repeated Member member = 2;
	required ChannelState channel_state = 3;
}

// ref: bnet.protocol.channel.ChannelDescription
message ChannelDescription {
	required bnet.protocol.EntityId channel_id = 1;
	optional uint32 current_members = 2;
	optional ChannelState state = 3;
}

// ref: bnet.protocol.channel.ChannelInfo
message ChannelInfo {
	required ChannelDescription description = 1;
	repeated Member member = 2;
}

// ref: bnet.protocol.channel.ChannelState
message chanChannelState {
	// ref: bnet.protocol.channel.ChannelState/Types/PrivacyLevel
	enum PrivacyLevel {
		PRIVACY_LEVEL_OPEN = 1;
		PRIVACY_LEVEL_OPEN_INVITATION_AND_FRIEND = 2;
		PRIVACY_LEVEL_OPEN_INVITATION = 3;
		PRIVACY_LEVEL_CLOSED = 4;
	}

	optional uint32 max_members = 1;
	optional uint32 min_members = 2;
	repeated bnet.protocol.Attribute attribute = 3;
	repeated bnet.protocol.Invitation invitation = 4;
	optional uint32 max_invitations = 5;
	optional uint32 reason = 6;
	optional PrivacyLevel privacy_level = 7 [default = PRIVACY_LEVEL_OPEN];
	optional string name = 8;
	optional string delegate_name = 9;
	optional string channel_type = 10 [default = "default"];
	optional fixed32 program = 11 [default = 0];
	optional bool allow_offline_members = 12 [default = false];
	optional bool subscribe_to_presence = 13 [default = true];
	optional bnet.protocol.ChannelState chat = 100; // chat
	optional bnet.protocol.PresenceChannelState presence = 101; // presence
}

// ref: bnet.protocol.channel.CreateChannelRequest
message CreateChannelRequest {
	optional bnet.protocol.Identity agent_identity = 1;
	optional MemberState member_state = 2;
	optional chanChannelState channel_state = 3;
	optional bnet.protocol.EntityId channel_id = 4;
	optional uint64 object_id = 5;
	optional bnet.protocol.EntityId local_agent = 6;
	optional MemberState local_member_state = 7;
}

// ref: bnet.protocol.channel.CreateChannelResponse
message CreateChannelResponse {
	required uint64 object_id = 1;
	optional bnet.protocol.EntityId channel_id = 2;
}

// ref: bnet.protocol.channel.DissolveRequest
message DissolveRequest {
	optional bnet.protocol.EntityId agent_id = 1;
	optional uint32 reason = 2;
}

// ref: bnet.protocol.channel.FindChannelOptions
message FindChannelOptions {
	optional uint32 start_index = 1 [default = 0];
	optional uint32 max_results = 2 [default = 16];
	optional string name = 3;
	optional fixed32 program = 4;
	optional fixed32 locale = 5;
	optional uint32 capacity_full = 6;
	required bnet.protocol.AttributeFilter attribute_filter = 7;
	optional string channel_type = 8;
}

// ref: bnet.protocol.channel.FindChannelRequest
message FindChannelRequest {
	optional bnet.protocol.Identity agent_identity = 1;
	required FindChannelOptions options = 2;
}

// ref: bnet.protocol.channel.FindChannelResponse
message FindChannelResponse {
	repeated ChannelDescription channel = 1;
}

// ref: bnet.protocol.channel.GetChannelIdRequest
message GetChannelIdRequest {
}

// ref: bnet.protocol.channel.GetChannelIdResponse
message GetChannelIdResponse {
	optional bnet.protocol.EntityId channel_id = 1;
}

// ref: bnet.protocol.channel.GetChannelInfoRequest
message GetChannelInfoRequest {
	optional bnet.protocol.EntityId agent_id = 1;
	required bnet.protocol.EntityId channel_id = 2;
	optional bool fetch_state = 3 [default = false];
	optional bool fetch_members = 4 [default = false];
}

// ref: bnet.protocol.channel.GetChannelInfoResponse
message GetChannelInfoResponse {
	optional ChannelInfo channel_info = 1;
}

// ref: bnet.protocol.channel.JoinChannelRequest
message JoinChannelRequest {
	optional bnet.protocol.Identity agent_identity = 1;
	optional MemberState member_state = 2;
	required bnet.protocol.EntityId channel_id = 3;
	required uint64 object_id = 4;
	repeated bnet.protocol.EntityId friend_account_id = 5;
	optional bool local_subscriber = 6 [default = true];
}

// ref: bnet.protocol.channel.JoinChannelResponse
message JoinChannelResponse {
	optional uint64 object_id = 1;
	optional bool require_friend_validation = 2 [default = false];
	repeated bnet.protocol.EntityId privileged_account = 3;
}

// ref: bnet.protocol.channel.JoinNotification
message JoinNotification {
	required Member member = 1;
}

// ref: bnet.protocol.channel.LeaveNotification
message LeaveNotification {
	optional bnet.protocol.EntityId agent_id = 1;
	required bnet.protocol.EntityId member_id = 2;
	optional uint32 reason = 3;
}

// ref: bnet.protocol.channel.Member
message Member {
	required bnet.protocol.Identity identity = 1;
	required MemberState state = 2;
}

// ref: bnet.protocol.channel.MemberState
message MemberState {
	repeated bnet.protocol.Attribute attribute = 1;
	repeated uint32 role = 2 [packed=true];
	optional uint64 privileges = 3 [default = 0];
	optional bnet.protocol.AccountInfo info = 4;
	optional bool hidden = 5 [default = false];
}

// ref: bnet.protocol.channel.Message
message Message {
	repeated bnet.protocol.Attribute attribute = 1;
	optional uint32 role = 2;
}

// ref: bnet.protocol.channel.RemoveMemberRequest
message RemoveMemberRequest {
	optional bnet.protocol.EntityId agent_id = 1;
	required bnet.protocol.EntityId member_id = 2;
	optional uint32 reason = 3;
}

// ref: bnet.protocol.channel.RemoveNotification
message RemoveNotification {
	optional bnet.protocol.EntityId agent_id = 1;
	required bnet.protocol.EntityId member_id = 2;
	optional uint32 reason = 3;
}

// ref: bnet.protocol.channel.SendMessageNotification
message SendMessageNotification {
	optional bnet.protocol.EntityId agent_id = 1;
	required Message message = 2;
	optional uint64 required_privileges = 3 [default = 0];
}

// ref: bnet.protocol.channel.SendMessageRequest
message SendMessageRequest {
	optional bnet.protocol.EntityId agent_id = 1;
	required Message message = 2;
	optional uint64 required_privileges = 3 [default = 0];
}

// ref: bnet.protocol.channel.SetRolesRequest
message SetRolesRequest {
	optional bnet.protocol.EntityId agent_id = 1;
	repeated uint32 role = 2 [packed=true];
	repeated bnet.protocol.EntityId member_id = 3;
}

// ref: bnet.protocol.channel.SubscribeChannelRequest
message SubscribeChannelRequest {
	optional bnet.protocol.EntityId agent_id = 1;
	required bnet.protocol.EntityId channel_id = 2;
	required uint64 object_id = 3;
}

// ref: bnet.protocol.channel.SubscribeChannelResponse
message SubscribeChannelResponse {
	optional uint64 object_id = 1;
}

// ref: bnet.protocol.channel.UnsubscribeMemberRequest
message UnsubscribeMemberRequest {
	optional bnet.protocol.EntityId agent_id = 1;
	required bnet.protocol.EntityId member_id = 2;
}

// ref: bnet.protocol.channel.UpdateChannelStateNotification
message UpdateChannelStateNotification {
	optional bnet.protocol.EntityId agent_id = 1;
	required chanChannelState state_change = 2;
}

// ref: bnet.protocol.channel.UpdateChannelStateRequest
message UpdateChannelStateRequest {
	optional bnet.protocol.EntityId agent_id = 1;
	required chanChannelState state_change = 2;
}

// ref: bnet.protocol.channel.UpdateMemberStateNotification
message UpdateMemberStateNotification {
	optional bnet.protocol.EntityId agent_id = 1;
	repeated Member state_change = 2;
	repeated uint32 removed_role = 3 [packed=true];
}

// ref: bnet.protocol.channel.UpdateMemberStateRequest
message UpdateMemberStateRequest {
	optional bnet.protocol.EntityId agent_id = 1;
	repeated Member state_change = 2;
	repeated uint32 removed_role = 3 [packed=true];
}


// AMBIGOUS


// ref: bnet.protocol.channel_invitation.AcceptInvitationRequest
message AcceptInvitationRequest {
	optional bnet.protocol.EntityId agent_id = 1;
	optional bnet.protocol.MemberState member_state = 2;
	required fixed64 invitation_id = 3;
	required uint64 object_id = 4;
	optional bnet.protocol.EntityId channel_id = 5;
	optional uint32 service_type = 6;
	optional bool local_subscriber = 7 [default = true];
}

// ref: bnet.protocol.channel_invitation.AcceptInvitationResponse
message AcceptInvitationResponse {
	required uint64 object_id = 1;
}

// ref: bnet.protocol.channel_invitation.ChannelCount
message ChannelCount {
	optional bnet.protocol.EntityId channel_id = 1;
	optional string channel_type = 2 [default = "default"];
}

// ref: bnet.protocol.channel_invitation.ChannelCountDescription
message ChannelCountDescription {
	required uint32 service_type = 1;
	required fixed32 program = 2;
	optional string channel_type = 3 [default = "default"];
	optional bnet.protocol.EntityId channel_id = 4;
}

// ref: bnet.protocol.channel_invitation.ChannelInvitation
message ChannelInvitation {
	required bnet.protocol.ChannelDescription channel_description = 1;
	optional bool reserved = 2 [default = false];
	optional bool rejoin = 3 [default = false];
	required uint32 service_type = 4;
}

// ref: bnet.protocol.channel_invitation.ChannelInvitationParams
message ChannelInvitationParams {
	required bnet.protocol.EntityId channel_id = 1;
	optional bool reserved = 2;
	optional bool rejoin = 3;
	required uint32 service_type = 4;
}

// ref: bnet.protocol.channel_invitation.DecrementChannelCountRequest
message DecrementChannelCountRequest {
	required bnet.protocol.EntityId agent_id = 1;
	optional bnet.protocol.EntityId channel_id = 2;
	optional uint64 reservation_token = 3;
}

// ref: bnet.protocol.channel_invitation.HasRoomForInvitationRequest
message HasRoomForInvitationRequest {
	required uint32 service_type = 1;
	optional fixed32 program = 2;
	optional string channel_type = 3 [default = "default"];
}

// ref: bnet.protocol.channel_invitation.IncrementChannelCountRequest
message IncrementChannelCountRequest {
	required bnet.protocol.EntityId agent_id = 1;
	repeated ChannelCountDescription descriptions = 2;
}

// ref: bnet.protocol.channel_invitation.IncrementChannelCountResponse
message IncrementChannelCountResponse {
	repeated uint64 reservation_tokens = 1;
}

// ref: bnet.protocol.channel_invitation.InvitationAddedNotification
message InvitationAddedNotification {
	required bnet.protocol.Invitation invitation = 1;
}

// ref: bnet.protocol.channel_invitation.InvitationCollection
message InvitationCollection {
	optional uint32 service_type = 1;
	optional uint32 max_received_invitations = 2;
	optional uint64 object_id = 3;
	repeated bnet.protocol.Invitation received_invitation = 4;
}

// ref: bnet.protocol.channel_invitation.InvitationRemovedNotification
message InvitationRemovedNotification {
	required bnet.protocol.Invitation invitation = 1;
	optional uint32 reason = 2;
}

// ref: bnet.protocol.channel_invitation.ListChannelCountRequest
message ListChannelCountRequest {
	required bnet.protocol.EntityId member_id = 1;
	required uint32 service_type = 2;
	optional fixed32 program = 3;
}

// ref: bnet.protocol.channel_invitation.ListChannelCountResponse
message ListChannelCountResponse {
	repeated ChannelCount channel = 1;
}

// ref: bnet.protocol.channel_invitation.RevokeInvitationRequest
message RevokeInvitationRequest {
	optional bnet.protocol.EntityId agent_id = 1;
	optional bnet.protocol.EntityId target_id = 2;
	required fixed64 invitation_id = 3;
	required bnet.protocol.EntityId channel_id = 4;
}

// ref: bnet.protocol.channel_invitation.SubscribeRequest
message CISubscribeRequest {
	optional bnet.protocol.EntityId agent_id = 1;
	required uint64 object_id = 2;
}

// ref: bnet.protocol.channel_invitation.SubscribeResponse
message CISubscribeResponse {
	repeated InvitationCollection collection = 1;
	repeated bnet.protocol.Invitation received_invitation = 2;
}

// ref: bnet.protocol.channel_invitation.SuggestInvitationRequest
message SuggestInvitationRequest {
	optional bnet.protocol.EntityId agent_id = 1;
	required bnet.protocol.EntityId channel_id = 2;
	required bnet.protocol.EntityId target_id = 3;
	optional bnet.protocol.EntityId approval_id = 4;
	optional bnet.protocol.Identity agent_identity = 5;
	optional bnet.protocol.AccountInfo agent_info = 6;
}

// ref: bnet.protocol.channel_invitation.SuggestionAddedNotification
message SuggestionAddedNotification {
	required bnet.protocol.Suggestion suggestion = 1;
}

// ref: bnet.protocol.channel_invitation.UnsubscribeRequest
message CIUnsubscribeRequest {
	optional bnet.protocol.EntityId agent_id = 1;
}

// ref: bnet.protocol.channel_invitation.UpdateChannelCountRequest
message UpdateChannelCountRequest {
	required bnet.protocol.EntityId agent_id = 1;
	optional uint64 reservation_token = 2;
	required bnet.protocol.EntityId channel_id = 3;
}

// ref: PegasusUtil.GoldBalance
message GoldBalance {
	// ref: PegasusUtil.GoldBalance/Types/PacketID
	enum PacketID {
		ID = 278;
	}

	optional int64 capped_balance = 1;
	optional int64 bonus_balance = 2;
	optional int64 cap = 3;
	optional int64 cap_warning = 4;
}

// ref: PegasusUtil.Subscribe
message Subscribe {
	// ref: PegasusUtil.Subscribe/PacketID
	enum PacketID {
		ID = 314;
	}

}

// ref: PegasusUtil.SubscribeResponse
message UtilSubscribeResponse {
	// ref: PegasusUtil.SubscribeResponse/PacketID
	enum PacketID {
		ID = 315;
	}

	// ref: PegasusUtil.SubscribeResponse/ResponseResult
	enum ResponseResult {
		SUCCESS = 1;
		FAILED_UNAVAILABLE = 2;
	}

	optional uint64 route = 1;
	optional uint64 keep_alive_secs = 3;
	optional uint64 max_resubscribe_attempts = 4 [default = 0];
	optional uint64 pending_response_timeout = 5 [default = 0];
	optional uint64 pending_subscribe_timeout = 6 [default = 0];
	optional ResponseResult result = 7 [default = SUCCESS];
	optional uint64 request_max_wait_secs = 8;
}

// ref: PegasusUtil.GenericData
message GenericData {
	required uint32 type_id = 1;
	required bytes data = 2;
}

// ref: PegasusUtil.GenericRequest
message UtilGenericRequest {
	required int32 request_id = 1;
	optional GenericData generic_data = 2;
	optional int32 request_sub_id = 3;
}

// ref: PegasusUtil.GenericRequestList
message GenericRequestList {
	// ref: PegasusUtil.GenericRequestList/PacketID
	enum PacketID {
		system = 0;
		ID = 327;
	}

	repeated UtilGenericRequest requests = 1;
}

// ref: PegasusUtil.GetPurchaseMethod
message GetPurchaseMethod {
	// ref: PegasusUtil.GetPurchaseMethod/PacketID
	enum PacketID {
		system = 1;
		ID = 250;
	}

	required string product_id = 1;
	required int32 quantity = 2;
	required int32 currency = 3;
	required string device_id = 4;
	optional Platform platform = 5;
}

// ref: PegasusShared.Platform
message Platform {
	required int32 os = 1;
	required int32 screen = 2;
	required string name = 3;
	optional int32 store = 4;
}

// ref: PegasusUtil.CheckAccountLicenses
message CheckAccountLicenses {
	// ref: PegasusUtil.CheckAccountLicenses/PacketID
	enum PacketID {
		system = 0;
		ID = 267;
	}

}

// ref: PegasusUtil.CheckAccountLicensesResponse
message CheckAccountLicensesResponse {
	// ref: PegasusUtil.CheckAccountLicensesResponse/PacketID
	enum PacketID {
		ID = 330;
	}

	required bool success = 1;
}

// ref: PegasusUtil.UpdateLogin
message UpdateLogin {
	// ref: PegasusUtil.UpdateLogin/PacketID
	enum PacketID {
		system = 0;
		ID = 205;
	}

	optional bool reply_required = 1;
	optional string referral = 2;
	optional string device_model_deprecated = 3;
}


// ref: PegasusUtil.CheckGameLicenses
message CheckGameLicenses {
	// ref: PegasusUtil.CheckGameLicenses/PacketID
	enum PacketID {
		system = 1;
		ID = 276;
	}

}

// ref: PegasusUtil.GetAchieves
message GetAchieves {
	// ref: PegasusUtil.GetAchieves/PacketID
	enum PacketID {
		system = 0;
		ID = 253;
	}

	optional bool only_active_or_new_complete = 1;
	optional string device_model = 2;
}

// ref: PegasusUtil.CheckGameLicensesResponse
message CheckGameLicensesResponse {
	// ref: PegasusUtil.CheckGameLicensesResponse/PacketID
	enum PacketID {
		ID = 331;
	}

	required bool success = 1;
}

// ref: PegasusUtil.GetAdventureProgress
message GetAdventureProgress {
	// ref: PegasusUtil.GetAdventureProgress/PacketID
	enum PacketID {
		system = 0;
		ID = 305;
	}

}

// ref: PegasusUtil.SetOptions
message SetOptions {
	// ref: PegasusUtil.SetOptions/MaxOptionCount
	enum MaxOptionCount {
		LIMIT = 51;
	}

	// ref: PegasusUtil.SetOptions/PacketID
	enum PacketID {
		system = 0;
		ID = 239;
	}

	repeated ClientOption options = 1;
}

// ref: PegasusUtil.ClientOption
message ClientOption {
	required int32 index = 1;
	optional bool as_bool = 2;
	optional int32 as_int32 = 3;
	optional int64 as_int64 = 4;
	optional float as_float = 5;
	optional uint64 as_uint64 = 6;
}

// ref: PegasusUtil.GuardianVars
message GuardianVars {
	// ref: PegasusUtil.GuardianVars/PacketID
	enum PacketID {
		ID = 264;
	}

	optional bool tourney = 1;
	optional bool practice = 2;
	optional bool casual = 3;
	optional bool forge = 4;
	optional bool friendly = 5;
	optional bool manager = 6;
	optional bool crafting = 7;
	optional bool hunter = 8;
	optional bool mage = 9;
	optional bool paladin = 10;
	optional bool priest = 11;
	optional bool rogue = 12;
	optional bool shaman = 13;
	optional bool warlock = 14;
	optional bool warrior = 15;
	optional int32 show_user_ui = 16;
	optional bool store = 17;
	optional bool battle_pay = 18;
	optional bool buy_with_gold = 19;
	optional bool tavern_brawl = 20;
	optional int32 client_options_update_interval_seconds = 21;
}

// ref: PegasusUtil.AssetsVersionResponse
message AssetsVersionResponse {
	// ref: PegasusUtil.AssetsVersionResponse/PacketID
	enum PacketID {
		ID = 304;
	}

	required int32 version = 1;
}

// ref: PegasusUtil.GenericResponse
message GenericResponse {
	// ref: PegasusUtil.GenericResponse/PacketID
	enum PacketID {
		ID = 326;
	}

	// ref: PegasusUtil.GenericResponse/Result
	enum Result {
		RESULT_OK = 0;
		RESULT_REQUEST_IN_PROCESS = 1;
		RESULT_REQUEST_COMPLETE = 2;
		RESULT_UNKNOWN_ERROR = 100;
		RESULT_INTERNAL_ERROR = 101;
		RESULT_DB_ERROR = 102;
		RESULT_INVALID_REQUEST = 103;
		RESULT_LOGIN_LOAD = 104;
		RESULT_DATA_MIGRATION_ERROR = 105;
	}

	required Result result_code = 1;
	required int32 request_id = 2;
	optional int32 request_sub_id = 3;
	optional GenericData generic_data = 4;
}

// ref: PegasusUtil.UpdateLoginComplete
message UpdateLoginComplete {
	// ref: PegasusUtil.UpdateLoginComplete/PacketID
	enum PacketID {
		ID = 307;
	}

}

// ref: PegasusUtil.ProfileProgress
message ProfileProgress {
	// ref: PegasusUtil.ProfileProgress/PacketID
	enum PacketID {
		ID = 233;
	}

	required int64 progress = 1;
	required int32 best_forge = 2;
	optional Date last_forge = 3;
	optional int32 display_banner = 4 [default = 0];
	repeated AdventureOptions adventure_options = 5;
}

// ref: PegasusUtil.AdventureOptions
message AdventureOptions {
	required int32 adventure_id = 1;
	required uint64 options = 2;
}

// ref: PegasusShared.Date
message Date {
	required int32 year = 1;
	required int32 month = 2;
	required int32 day = 3;
	required int32 hours = 4;
	required int32 min = 5;
	required int32 sec = 6;
}

// ref: PegasusUtil.DeckList
message DeckList {
	// ref: PegasusUtil.DeckList/PacketID
	enum PacketID {
		ID = 202;
	}

	repeated DeckInfo decks = 1;
}

// ref: PegasusShared.DeckInfo
message DeckInfo {
	// ref: PegasusShared.DeckInfo/ValidityFlags
	enum ValidityFlags {
		UNLOCKED_HERO_CLASS = 1;
		OWNS_CARDS = 2;
		HAS_30_CARDS = 4;
		OBEYS_MAXES = 8;
		CLASS_MATCHES = 16;
		OWNS_CARD_BACK = 32;
		OWNS_HERO = 64;
		TAGGED_STANDARD = 128;
		NEEDS_VALIDATION = 256;
		NEEDS_NAME = 512;
	}

	required int64 id = 1;
	required string name = 2;
	required int32 card_back = 3;
	required int32 hero = 4;
	required DeckType deck_type = 5;
	required uint64 validity = 6;
	required int32 hero_premium = 7;
	required bool card_back_override = 8;
	required bool hero_override = 9;
	optional int64 last_modified = 10;
	optional int32 season_id = 11;
	optional int64 sort_order = 12;
	optional int64 create_date = 13;
	optional DeckSourceType source_type = 14 [default = DECK_SOURCE_TYPE_UNKNOWN];
}

// ref: PegasusShared.DeckSourceType
enum DeckSourceType {
	DECK_SOURCE_TYPE_UNKNOWN = 0;
	DECK_SOURCE_TYPE_NORMAL = 1;
	DECK_SOURCE_TYPE_TEMPLATE = 2;
	DECK_SOURCE_TYPE_BASIC_DECK = 3;
}

// ref: PegasusShared.DeckType
enum DeckType {
	NORMAL_DECK = 1;
	AI_DECK = 2;
	DRAFT_DECK = 4;
	PRECON_DECK = 5;
	TAVERN_BRAWL_DECK = 6;
	HIDDEN_DECK = 1000;
}

// ref: PegasusUtil.BoosterList
message BoosterList {
	// ref: PegasusUtil.BoosterList/PacketID
	enum PacketID {
		ID = 224;
	}

	repeated BoosterInfo list = 1;
}

// ref: PegasusShared.BoosterInfo
message BoosterInfo {
	required int32 type = 2;
	required int32 count = 3;
}


// ref: PegasusUtil.Collection
message Collection {
	// ref: PegasusUtil.Collection/PacketID
	enum PacketID {
		ID = 207;
	}

	repeated CardStack stacks = 1;
}

// ref: PegasusShared.CardDef
message CardDef {
	required int32 asset = 1;
	optional int32 premium = 2;
}

// ref: PegasusShared.CardStack
message CardStack {
	required CardDef card_def = 1;
	required Date latest_insert_date = 2;
	required int32 count = 3;
	required int32 num_seen = 4;
}


// ref: PegasusUtil.MedalInfo
message MedalInfo {
	// ref: PegasusUtil.MedalInfo/PacketID
	enum PacketID {
		ID = 232;
	}

	required MedalInfoData standard = 1;
	required MedalInfoData wild = 2;
}

// ref: PegasusUtil.MedalInfoData
message MedalInfoData {
	required int32 season_wins = 3;
	required int32 stars = 6;
	required int32 streak = 7;
	required int32 star_level = 8;
	required int32 level_start = 9;
	required int32 level_end = 10;
	required bool can_lose_level = 11;
	optional int32 legend_rank = 13;
	optional int32 best_star_level = 14;
	optional bool can_lose_stars = 15;
}

// ref: PegasusUtil.SpecialEventTiming
message SpecialEventTiming {
	required string event = 1;
	optional uint64 start = 2;
	optional uint64 end = 3;
}

// ref: PegasusUtil.NotSoMassiveLoginReply
message NotSoMassiveLoginReply {
	// ref: PegasusUtil.NotSoMassiveLoginReply/PacketID
	enum PacketID {
		ID = 300;
	}

	repeated SpecialEventTiming special_event_timing = 10;
	optional TavernBrawlInfo tavern_brawls = 11;
}

// ref: PegasusUtil.TavernBrawlInfo
message TavernBrawlInfo {
	// ref: PegasusUtil.TavernBrawlInfo/PacketID
	enum PacketID {
		ID = 316;
	}

	optional TavernBrawlSpec current_tavern_brawl = 1;
	optional uint64 next_start_seconds_from_now = 2;
}

// ref: PegasusShared.TavernBrawlSpec
message TavernBrawlSpec {
	optional uint64 end_seconds_from_now = 1;
	required int32 scenario_id = 2;
	required uint32 scenario_record_byte_size = 3;
	required bytes scenario_record_hash = 4;
	required RewardType reward_type = 5;
	required int64 reward_data1 = 6;
	required int64 reward_data2 = 7;
	optional RewardTrigger reward_trigger = 8 [default = REWARD_TRIGGER_UNKNOWN];
	required int32 season_id = 11;
	repeated AssetRecordInfo additional_assets = 100;
	required TavernBrawlPlayerRecord my_record = 105;
}

// ref: PegasusShared.RewardType
enum RewardType {
	REWARD_UNKNOWN = 0;
	REWARD_NONE = 1;
	REWARD_ADVENTURE_PROGRESS = 2;
	REWARD_ARCANE_DUST = 3;
	REWARD_BASIC_CARD = 4;
	REWARD_BOOSTER_PACKS = 5;
	REWARD_CARD_BACK = 6;
	REWARD_CARD_ID = 7;
	REWARD_CARD_ID_2X = 8;
	REWARD_CARD_SET = 9;
	DEPRECATED_REWARD_CRAFTABLE_GOLDEN = 10;
	REWARD_GOLD = 11;
	REWARD_GOLD_HERO = 12;
	REWARD_FORGE_TICKETS = 13;
	REWARD_HERO = 14;
	REWARD_EXTERNAL_GAME_MOUNT = 15;
}

// ref: PegasusShared.RewardTrigger
enum RewardTrigger {
	REWARD_TRIGGER_UNKNOWN = 0;
	REWARD_TRIGGER_NONE = 1;
	REWARD_TRIGGER_WIN_GAME = 2;
	REWARD_TRIGGER_FINISH_GAME = 3;
}

// ref: PegasusShared.AssetRecordInfo
message AssetRecordInfo {
	required AssetKey asset = 1;
	required uint32 record_byte_size = 2;
	required bytes record_hash = 3;
}

// ref: PegasusShared.TavernBrawlPlayerRecord
message TavernBrawlPlayerRecord {
	required int32 reward_progress = 1;
	optional int32 games_played = 2;
	required int32 games_won = 3;
	optional int32 win_streak = 4;
}

// ref: PegasusShared.AssetKey
message AssetKey {
	required AssetType type = 1;
	optional int32 asset_id = 2;
}

// ref: PegasusShared.AssetType
enum AssetType {
	ASSET_TYPE_SCENARIO = 1;
	ASSET_TYPE_SUBSET_CARD = 2;
	ASSET_TYPE_DECK_RULESET = 3;
}


// ref: PegasusUtil.CardValue
message CardValue {
	required CardDef card = 1;
	required int32 buy = 2;
	required int32 sell = 3;
	required bool nerfed = 4;
}

// ref: PegasusUtil.CardValues
message CardValues {
	// ref: PegasusUtil.CardValues/PacketID
	enum PacketID {
		ID = 260;
	}

	repeated CardValue cards = 1;
	required int32 card_nerf_index = 2;
}

// ref: PegasusUtil.RewardProgress
message RewardProgress {
	// ref: PegasusUtil.RewardProgress/PacketID
	enum PacketID {
		ID = 271;
	}

	required Date season_end = 1;
	required int32 wins_per_gold = 2;
	required int32 gold_per_reward = 3;
	required int32 max_gold_per_day = 4;
	required int32 season_number = 5;
	optional int32 pack_id = 8;
	required int32 xp_solo_limit = 9;
	required int32 max_hero_level = 10;
	required Date next_quest_cancel = 11;
	required float event_timing_mod = 12;
}

// ref: PegasusUtil.PlayerRecord
message PlayerRecord {
	required GameType type = 1;
	optional int32 data = 2;
	required int32 wins = 3;
	required int32 losses = 4;
	optional int32 ties = 5;
}

// ref: PegasusShared.GameType
enum GameType {
	GT_UNKNOWN = 0;
	GT_VS_AI = 1;
	GT_VS_FRIEND = 2;
	GT_TUTORIAL = 4;
	GT_ARENA = 5;
	GT_TEST = 6;
	GT_RANKED = 7;
	GT_CASUAL = 8;
	GT_TAVERNBRAWL = 16;
	GT_TB_1P_VS_AI = 17;
	GT_TB_2P_COOP = 18;
	GT_LAST = 19;
}

// ref: PegasusUtil.PlayerRecords
message PlayerRecords {
	// ref: PegasusUtil.PlayerRecords/PacketID
	enum PacketID {
		ID = 270;
	}

	repeated PlayerRecord records = 1;
}

// ref: PegasusUtil.ArcaneDustBalance
message ArcaneDustBalance {
	// ref: PegasusUtil.ArcaneDustBalance/PacketID
	enum PacketID {
		ID = 262;
	}

	required int64 balance = 1;
}

// ref: PegasusUtil.ClientOptions
message ClientOptions {
	// ref: PegasusUtil.ClientOptions/PacketID
	enum PacketID {
		ID = 241;
	}

	repeated ClientOption options = 1;
	optional bool failed = 2;
}

// ref: PegasusUtil.AdventureProgressResponse
message AdventureProgressResponse {
	// ref: PegasusUtil.AdventureProgressResponse/PacketID
	enum PacketID {
		ID = 306;
	}

	repeated AdventureProgress list = 1;
}

// ref: PegasusShared.AdventureProgress
message AdventureProgress {
	// ref: PegasusShared.AdventureProgress/Flags
	enum Flags {
		OWNED = 1;
		DEFEAT_HEROIC_MISSION_1 = 2;
		DEFEAT_HEROIC_MISSION_2 = 4;
		DEFEAT_HEROIC_MISSION_3 = 8;
		DEFEAT_HEROIC_MISSION_4 = 16;
		DEFEAT_CLASS_CHALLENGE_MISSION_1 = 256;
		DEFEAT_CLASS_CHALLENGE_MISSION_2 = 512;
	}

	required int32 wing_id = 1;
	required int32 progress = 2;
	optional int32 ack = 3 [default = 0];
	required uint64 flags = 4;
}

// ref: PegasusUtil.HeroXP
message HeroXP {
	// ref: PegasusUtil.HeroXP/PacketID
	enum PacketID {
		ID = 283;
	}

	repeated HeroXPInfo xp_infos = 1;
}

// ref: PegasusUtil.HeroXPInfo
message HeroXPInfo {
	required int32 class_id = 1;
	required int32 level = 2;
	required int64 curr_xp = 3;
	required int64 max_xp = 4;
	optional NextHeroLevelReward next_reward = 5;
}

// ref: PegasusUtil.NextHeroLevelReward
message NextHeroLevelReward {
	required int32 level = 1;
	optional ProfileNoticeRewardBooster reward_booster = 2;
	optional ProfileNoticeRewardCard reward_card = 3;
	optional ProfileNoticeRewardDust reward_dust = 4;
	optional ProfileNoticeRewardGold reward_gold = 5;
	optional ProfileNoticeRewardMount reward_mount = 6;
	optional ProfileNoticeRewardForge reward_forge = 7;
}

// ref: PegasusShared.ProfileNoticeRewardForge
message ProfileNoticeRewardForge {
	// ref: PegasusShared.ProfileNoticeRewardForge/NoticeID
	enum NoticeID {
		ID = 8;
	}

	required int32 quantity = 1;
}

// ref: PegasusShared.ProfileNoticeRewardMount
message ProfileNoticeRewardMount {
	// ref: PegasusShared.ProfileNoticeRewardMount/NoticeID
	enum NoticeID {
		ID = 7;
	}

	required int32 mount_id = 1;
}

// ref: PegasusShared.ProfileNoticeRewardGold
message ProfileNoticeRewardGold {
	// ref: PegasusShared.ProfileNoticeRewardGold/NoticeID
	enum NoticeID {
		ID = 9;
	}

	required int32 amount = 1;
}

// ref: PegasusShared.ProfileNoticeRewardDust
message ProfileNoticeRewardDust {
	// ref: PegasusShared.ProfileNoticeRewardDust/NoticeID
	enum NoticeID {
		ID = 6;
	}

	required int32 amount = 1;
}

// ref: PegasusShared.ProfileNoticeRewardCard
message ProfileNoticeRewardCard {
	// ref: PegasusShared.ProfileNoticeRewardCard/NoticeID
	enum NoticeID {
		ID = 3;
	}

	required CardDef card = 1;
	optional int32 quantity = 2;
}

// ref: PegasusShared.ProfileNoticeRewardBooster
message ProfileNoticeRewardBooster {
	// ref: PegasusShared.ProfileNoticeRewardBooster/NoticeID
	enum NoticeID {
		ID = 2;
	}

	required int32 booster_type = 1;
	required int32 booster_count = 2;
}

// ref: PegasusUtil.FavoriteHeroesResponse
message FavoriteHeroesResponse {
	// ref: PegasusUtil.FavoriteHeroesResponse/PacketID
	enum PacketID {
		ID = 318;
	}

	repeated FavoriteHero favorite_heroes = 1;
}

// ref: PegasusShared.FavoriteHero
message FavoriteHero {
	required int32 class_id = 1;
	required CardDef hero = 2;
}

// ref: PegasusUtil.CardBacks
message CardBacks {
	// ref: PegasusUtil.CardBacks/PacketID
	enum PacketID {
		system = 0;
		ID = 236;
	}

	required int32 default_card_back = 1;
	repeated int32 card_backs = 2;
}

// ref: PegasusUtil.AccountLicensesInfoResponse
message AccountLicensesInfoResponse {
	// ref: PegasusUtil.AccountLicensesInfoResponse/PacketID
	enum PacketID {
		ID = 325;
	}

	repeated AccountLicenseInfo list = 1;
}

// ref: PegasusShared.AccountLicenseInfo
message AccountLicenseInfo {
	// ref: PegasusShared.AccountLicenseInfo/Flags
	enum Flags {
		OWNED = 1;
	}

	required int64 license = 1;
	required uint64 flags = 2;
	required int64 cas_id = 3;
}

// ref: PegasusUtil.ProfileNotice
message ProfileNotice {
	required int64 entry = 1;
	optional ProfileNoticeMedal medal = 2;
	optional ProfileNoticeRewardBooster reward_booster = 3;
	optional ProfileNoticeRewardCard reward_card = 4;
	optional ProfileNoticePreconDeck precon_deck = 6;
	optional ProfileNoticeRewardDust reward_dust = 7;
	optional ProfileNoticeRewardGold reward_gold = 8;
	optional ProfileNoticeRewardMount reward_mount = 9;
	optional ProfileNoticeRewardForge reward_forge = 10;
	required int32 origin = 11;
	optional int64 origin_data = 12;
	required Date when = 13;
	optional ProfileNoticePurchase purchase = 14;
	optional ProfileNoticeCardBack reward_card_back = 15;
	optional ProfileNoticeDisconnectedGameResult dc_game_result = 16;
	optional ProfileNoticeBonusStars bonus_stars = 17;
	optional ProfileNoticeAdventureProgress adventure_progress = 18;
	optional ProfileNoticeLevelUp level_up = 19;
	optional ProfileNoticeAccountLicense account_license = 20;
}

// ref: PegasusUtil.ProfileNotices
message ProfileNotices {
	// ref: PegasusUtil.ProfileNotices/PacketID
	enum PacketID {
		ID = 212;
	}

	repeated ProfileNotice list = 1;
}

// ref: PegasusShared.ProfileNoticeMedal
message ProfileNoticeMedal {
	// ref: PegasusShared.ProfileNoticeMedal/MedalType
	enum MedalType {
		UNKNOWN_MEDAL = 0;
		STANDARD_MEDAL = 1;
		WILD_MEDAL = 2;
	}

	// ref: PegasusShared.ProfileNoticeMedal/NoticeID
	enum NoticeID {
		ID = 1;
	}

	required int32 star_level = 1;
	optional int32 legend_rank = 2;
	optional int32 best_star_level = 3;
	optional RewardChest chest = 4;
	optional MedalType medal_type = 5 [default = UNKNOWN_MEDAL];
}

// ref: PegasusShared.ProfileNoticePreconDeck
message ProfileNoticePreconDeck {
	// ref: PegasusShared.ProfileNoticePreconDeck/NoticeID
	enum NoticeID {
		ID = 5;
	}

	required int64 deck = 1;
	required int32 hero = 2;
}

// ref: PegasusShared.ProfileNoticePurchase
message ProfileNoticePurchase {
	// ref: PegasusShared.ProfileNoticePurchase/NoticeID
	enum NoticeID {
		ID = 10;
	}

	required string product_id = 1;
	optional int64 data = 2;
	optional int32 currency = 3;
}

// ref: PegasusShared.ProfileNoticeCardBack
message ProfileNoticeCardBack {
	// ref: PegasusShared.ProfileNoticeCardBack/NoticeID
	enum NoticeID {
		ID = 11;
	}

	required int32 card_back = 1;
}

// ref: PegasusShared.ProfileNoticeDisconnectedGameResult
message ProfileNoticeDisconnectedGameResult {
	// ref: PegasusShared.ProfileNoticeDisconnectedGameResult/GameResult
	enum GameResult {
		GR_UNKNOWN = 0;
		GR_PLAYING = 1;
		GR_WINNER = 2;
		GR_TIE = 3;
	}

	// ref: PegasusShared.ProfileNoticeDisconnectedGameResult/NoticeID
	enum NoticeID {
		ID = 4;
	}

	// ref: PegasusShared.ProfileNoticeDisconnectedGameResult/PlayerResult
	enum PlayerResult {
		PR_UNKNOWN = 0;
		PR_WON = 1;
		PR_LOST = 2;
		PR_DISCONNECTED = 3;
		PR_QUIT = 4;
	}

	optional GameType game_type = 8 [default = GT_UNKNOWN];
	optional int32 mission_id = 9;
	optional GameResult game_result = 10 [default = GR_UNKNOWN];
	optional PlayerResult your_result = 11 [default = PR_UNKNOWN];
	optional PlayerResult opponent_result = 12 [default = PR_UNKNOWN];
}

// ref: PegasusShared.ProfileNoticeBonusStars
message ProfileNoticeBonusStars {
	// ref: PegasusShared.ProfileNoticeBonusStars/NoticeID
	enum NoticeID {
		ID = 12;
	}

	required int32 star_level = 1;
	required int32 stars = 2;
}

// ref: PegasusShared.ProfileNoticeAdventureProgress
message ProfileNoticeAdventureProgress {
	// ref: PegasusShared.ProfileNoticeAdventureProgress/NoticeID
	enum NoticeID {
		ID = 14;
	}

	required int32 wing_id = 1;
}

// ref: PegasusShared.ProfileNoticeLevelUp
message ProfileNoticeLevelUp {
	// ref: PegasusShared.ProfileNoticeLevelUp/NoticeID
	enum NoticeID {
		ID = 15;
	}

	required int32 hero_class = 1;
	required int32 new_level = 2;
}

// ref: PegasusShared.ProfileNoticeAccountLicense
message ProfileNoticeAccountLicense {
	// ref: PegasusShared.ProfileNoticeAccountLicense/NoticeID
	enum NoticeID {
		ID = 16;
	}

	required int64 license = 1;
	required int64 cas_id = 2;
}

// ref: PegasusShared.RewardBag
message RewardBag {
	optional ProfileNoticeRewardBooster reward_booster = 1;
	optional ProfileNoticeRewardCard reward_card = 2;
	optional ProfileNoticeRewardDust reward_dust = 3;
	optional ProfileNoticeRewardGold reward_gold = 4;
	optional ProfileNoticeCardBack reward_card_back = 5;
}

// ref: PegasusShared.RewardChest
message RewardChest {
	optional RewardBag bag1 = 1;
	optional RewardBag bag2 = 2;
	optional RewardBag bag3 = 3;
	optional RewardBag bag4 = 4;
	optional RewardBag bag5 = 5;
}

// ref: PegasusUtil.BattlePayConfigResponse
message BattlePayConfigResponse {
	// ref: PegasusUtil.BattlePayConfigResponse/PacketID
	enum PacketID {
		ID = 238;
	}

	repeated Bundle bundles = 1;
	optional int32 currency = 2;
	optional bool unavailable = 4;
	optional int32 secs_before_auto_cancel = 5;
	repeated GoldCostBooster gold_cost_boosters = 6;
	optional int64 gold_cost_arena = 7;
}

// ref: PegasusUtil.GoldCostBooster
message GoldCostBooster {
	required int64 cost = 1;
	required int32 pack_type = 2;
	optional string buy_with_gold_event_name = 3;
}

// ref: PegasusUtil.Bundle
message Bundle {
	required string id = 1;
	optional double cost = 2;
	optional string apple_id = 3;
	optional string google_play_id = 4;
	repeated BundleItem items = 5;
	optional int64 gold_cost = 6;
	optional string amazon_id = 7;
	optional string product_event_name = 9;
	repeated BattlePayProvider exclusive_providers = 10;
	optional string real_money_product_event_name = 11;
}

// ref: PegasusUtil.BundleItem
message BundleItem {
	required ProductType product_type = 1;
	required int32 data = 2;
	required int32 quantity = 3;
}

// ref: PegasusUtil.ProductType
enum ProductType {
	PRODUCT_TYPE_UNKNOWN = 0;
	PRODUCT_TYPE_BOOSTER = 1;
	PRODUCT_TYPE_DRAFT = 2;
	PRODUCT_TYPE_NAXX = 3;
	PRODUCT_TYPE_BRM = 4;
	PRODUCT_TYPE_CARD_BACK = 5;
	PRODUCT_TYPE_HERO = 6;
	PRODUCT_TYPE_LOE = 7;
}

// ref: PegasusShared.BattlePayProvider
enum BattlePayProvider {
	BP_PROVIDER_BLIZZARD = 1;
	BP_PROVIDER_APPLE = 2;
	BP_PROVIDER_GOOGLE_PLAY = 3;
	BP_PROVIDER_AMAZON = 4;
}

// ref: PegasusUtil.BattlePayStatusResponse
message BattlePayStatusResponse {
	// ref: PegasusUtil.BattlePayStatusResponse/PacketID
	enum PacketID {
		ID = 265;
	}

	// ref: PegasusUtil.BattlePayStatusResponse/PurchaseState
	enum PurchaseState {
		PS_READY = 0;
		PS_CHECK_RESULTS = 1;
		PS_ERROR = 2;
	}

	required PurchaseState status = 1;
	optional string product_id = 2;
	optional PurchaseError purchase_error = 3;
	required bool battle_pay_available = 4;
	optional int64 transaction_id = 5;
	optional string third_party_id = 6;
	optional int32 currency = 7;
	optional BattlePayProvider provider = 8 [default = BP_PROVIDER_BLIZZARD];
}

// ref: PegasusUtil.PurchaseError
message PurchaseError {
	// ref: PegasusUtil.PurchaseError/Error
	enum Error {
		E_UNKNOWN = -1;
		E_SUCCESS = 0;
		E_STILL_IN_PROGRESS = 1;
		E_INVALID_BNET = 2;
		E_SERVICE_NA = 3;
		E_PURCHASE_IN_PROGRESS = 4;
		E_DATABASE = 5;
		E_INVALID_QUANTITY = 6;
		E_DUPLICATE_LICENSE = 7;
		E_REQUEST_NOT_SENT = 8;
		E_NO_ACTIVE_BPAY = 9;
		E_FAILED_RISK = 10;
		E_CANCELED = 11;
		E_WAIT_MOP = 12;
		E_WAIT_CLIENT_CONFIRM = 13;
		E_WAIT_CLIENT_RISK = 14;
		E_PRODUCT_NA = 15;
		E_RISK_TIMEOUT = 16;
		E_PRODUCT_ALREADY_OWNED = 17;
		E_WAIT_THIRD_PARTY_RECEIPT = 18;
		E_PRODUCT_EVENT_HAS_ENDED = 19;
		E_BP_GENERIC_FAIL = 100;
		E_BP_INVALID_CC_EXPIRY = 101;
		E_BP_RISK_ERROR = 102;
		E_BP_NO_VALID_PAYMENT = 103;
		E_BP_PAYMENT_AUTH = 104;
		E_BP_PROVIDER_DENIED = 105;
		E_BP_PURCHASE_BAN = 106;
		E_BP_SPENDING_LIMIT = 107;
		E_BP_PARENTAL_CONTROL = 108;
		E_BP_THROTTLED = 109;
		E_BP_THIRD_PARTY_BAD_RECEIPT = 110;
		E_BP_THIRD_PARTY_RECEIPT_USED = 111;
		E_BP_PRODUCT_UNIQUENESS_VIOLATED = 112;
		E_BP_REGION_IS_DOWN = 113;
		E_BP_GENERIC_FAIL_RETRY_CONTACT_CS_IF_PERSISTS = 115;
		E_BP_CHALLENGE_ID_FAILED_VERIFICATION = 116;
	}

	required Error error = 1;
	optional string purchase_in_progress = 2;
	optional string error_code = 3;
}

// ref: PegasusUtil.PlayQueue
message PlayQueue {
	// ref: PegasusUtil.PlayQueue/PacketID
	enum PacketID {
		ID = 286;
	}

	required PlayQueueInfo queue = 1;
}

// ref: PegasusShared.PlayQueueInfo
message PlayQueueInfo {
	required BnetGameType game_type = 1;
}

// ref: PegasusShared.BnetGameType
enum BnetGameType {
	BGT_UNKNOWN = 0;
	BGT_FRIENDS = 1;
	BGT_RANKED_STANDARD = 2;
	BGT_ARENA = 3;
	BGT_VS_AI = 4;
	BGT_TUTORIAL = 5;
	BGT_ASYNC = 6;
	BGT_NEWBIE = 9;
	BGT_CASUAL_STANDARD = 10;
	BGT_TEST1 = 11;
	BGT_TEST2 = 12;
	BGT_TEST3 = 13;
	BGT_TAVERNBRAWL_PVP = 16;
	BGT_TAVERNBRAWL_1P_VERSUS_AI = 17;
	BGT_TAVERNBRAWL_2P_COOP = 18;
	BGT_RANKED_WILD = 30;
	BGT_CASUAL_WILD = 31;
	BGT_LAST = 32;
}

// ref: PegasusUtil.GetDeckContents
message GetDeckContents {
	// ref: PegasusUtil.GetDeckContents/PacketID
	enum PacketID {
		system = 0;
		ID = 214;
	}

	repeated int64 deck_id = 1;
}

// ref: PegasusUtil.GetDeckContentsResponse
message GetDeckContentsResponse {
	// ref: PegasusUtil.GetDeckContentsResponse/PacketID
	enum PacketID {
		ID = 215;
	}

	optional int64 deprecated_deck_id = 1;
	repeated DeckCardData deprecated_cards = 2;
	repeated DeckContents decks = 3;
}

// ref: PegasusShared.DeckCardData
message DeckCardData {
	required CardDef def = 1;
	required int32 handle = 2 [default = 0];
	optional int32 qty = 3;
	required int32 prev = 5 [default = 0];
}

// ref: PegasusUtil.DeckContents
message DeckContents {
	required bool success = 1;
	required int64 deck_id = 2;
	repeated DeckCardData cards = 3;
}

// ref: PegasusUtil.SetCardBack
message SetCardBack {
	// ref: PegasusUtil.SetCardBack/PacketID
	enum PacketID {
		system = 0;
		ID = 291;
	}

	required int32 card_back = 1;
	optional int64 deck_id = 2;
}

// ref: PegasusUtil.SetCardBackResponse
message SetCardBackResponse {
	// ref: PegasusUtil.SetCardBackResponse/PacketID
	enum PacketID {
		ID = 292;
	}

	required bool success = 1;
	required int32 card_back = 2;
}

// ref: PegasusUtil.OpenBooster
message OpenBooster {
	// ref: PegasusUtil.OpenBooster/PacketID
	enum PacketID {
		system = 0;
		ID = 225;
	}

	required int32 booster_type = 2;
}

// ref: PegasusUtil.BoosterCard
message BoosterCard {
	required CardDef card_def = 1;
	required Date insert_date = 2;
}

// ref: PegasusUtil.BoosterContent
message BoosterContent {
	// ref: PegasusUtil.BoosterContent/PacketID
	enum PacketID {
		ID = 226;
	}

	repeated BoosterCard list = 1;
}

// ref: PegasusUtil.AckCardSeen
message AckCardSeen {
	// ref: PegasusUtil.AckCardSeen/PacketID
	enum PacketID {
		system = 0;
		ID = 223;
	}

	repeated CardDef card_defs = 1;
}

// ref: PegasusUtil.PurchaseWithGold
message PurchaseWithGold {
	// ref: PegasusUtil.PurchaseWithGold/PacketID
	enum PacketID {
		system = 0;
		ID = 279;
	}

	required int32 quantity = 1;
	required ProductType product = 2;
	optional int32 data = 3;
}

// ref: PegasusUtil.PurchaseWithGoldResponse
message PurchaseWithGoldResponse {
	// ref: PegasusUtil.PurchaseWithGoldResponse/PacketID
	enum PacketID {
		ID = 280;
	}

	// ref: PegasusUtil.PurchaseWithGoldResponse/PurchaseResult
	enum PurchaseResult {
		PR_SUCCESS = 1;
		PR_INSUFFICIENT_FUNDS = 2;
		PR_PRODUCT_NA = 3;
		PR_FEATURE_NA = 4;
		PR_INVALID_QUANTITY = 5;
	}

	required PurchaseResult result = 1;
	optional int64 gold_used = 2;
}

// ref: PegasusUtil.BuySellCard
message BuySellCard {
	// ref: PegasusUtil.BuySellCard/PacketID
	enum PacketID {
		system = 0;
		ID = 257;
	}

	required CardDef def = 1;
	optional int32 count = 2;
	required bool buying = 3;
	optional int32 unit_sell_price = 4;
	optional int32 unit_buy_price = 5;
}

// ref: PegasusUtil.DeckRenamed
message DeckRenamed {
	// ref: PegasusUtil.DeckRenamed/PacketID
	enum PacketID {
		ID = 219;
	}

	required int64 deck = 1;
	required string name = 2;
}

// ref: PegasusUtil.DeckSetData
message DeckSetData {
	// ref: PegasusUtil.DeckSetData/PacketID
	enum PacketID {
		system = 0;
		ID = 222;
	}

	required int64 deck = 1;
	repeated DeckCardData cards = 2;
	optional CardDef hero = 3;
	optional int32 card_back = 4;
	optional bool tagged_standard = 5;
}

// ref: PegasusUtil.BoughtSoldCard
message BoughtSoldCard {
	// ref: PegasusUtil.BoughtSoldCard/PacketID
	enum PacketID {
		ID = 258;
	}

	// ref: PegasusUtil.BoughtSoldCard/Result
	enum Result {
		GENERIC_FAILURE = 1;
		SOLD = 2;
		BOUGHT = 3;
		SOULBOUND = 4;
		WRONG_SELL_PRICE = 5;
		WRONG_BUY_PRICE = 6;
		NO_PERMISSION = 7;
		EVENT_NOT_ACTIVE = 8;
	}

	required CardDef def = 1;
	required int32 amount = 2;
	required Result result = 3;
	optional int32 count = 4;
	optional bool nerfed = 5;
	optional int32 unit_sell_price = 6;
	optional int32 unit_buy_price = 7;
}