You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1849 lines
77 KiB
Go
1849 lines
77 KiB
Go
// Code generated by protoc-gen-go.
|
|
// source: dota_shared_enums.proto
|
|
// DO NOT EDIT!
|
|
|
|
package dota
|
|
|
|
import proto "github.com/golang/protobuf/proto"
|
|
import fmt "fmt"
|
|
import math "math"
|
|
|
|
// Reference imports to suppress errors if they are not otherwise used.
|
|
var _ = proto.Marshal
|
|
var _ = fmt.Errorf
|
|
var _ = math.Inf
|
|
|
|
type DOTA_GameMode int32
|
|
|
|
const (
|
|
DOTA_GameMode_DOTA_GAMEMODE_NONE DOTA_GameMode = 0
|
|
DOTA_GameMode_DOTA_GAMEMODE_AP DOTA_GameMode = 1
|
|
DOTA_GameMode_DOTA_GAMEMODE_CM DOTA_GameMode = 2
|
|
DOTA_GameMode_DOTA_GAMEMODE_RD DOTA_GameMode = 3
|
|
DOTA_GameMode_DOTA_GAMEMODE_SD DOTA_GameMode = 4
|
|
DOTA_GameMode_DOTA_GAMEMODE_AR DOTA_GameMode = 5
|
|
DOTA_GameMode_DOTA_GAMEMODE_INTRO DOTA_GameMode = 6
|
|
DOTA_GameMode_DOTA_GAMEMODE_HW DOTA_GameMode = 7
|
|
DOTA_GameMode_DOTA_GAMEMODE_REVERSE_CM DOTA_GameMode = 8
|
|
DOTA_GameMode_DOTA_GAMEMODE_XMAS DOTA_GameMode = 9
|
|
DOTA_GameMode_DOTA_GAMEMODE_TUTORIAL DOTA_GameMode = 10
|
|
DOTA_GameMode_DOTA_GAMEMODE_MO DOTA_GameMode = 11
|
|
DOTA_GameMode_DOTA_GAMEMODE_LP DOTA_GameMode = 12
|
|
DOTA_GameMode_DOTA_GAMEMODE_POOL1 DOTA_GameMode = 13
|
|
DOTA_GameMode_DOTA_GAMEMODE_FH DOTA_GameMode = 14
|
|
DOTA_GameMode_DOTA_GAMEMODE_CUSTOM DOTA_GameMode = 15
|
|
DOTA_GameMode_DOTA_GAMEMODE_CD DOTA_GameMode = 16
|
|
DOTA_GameMode_DOTA_GAMEMODE_BD DOTA_GameMode = 17
|
|
DOTA_GameMode_DOTA_GAMEMODE_ABILITY_DRAFT DOTA_GameMode = 18
|
|
DOTA_GameMode_DOTA_GAMEMODE_EVENT DOTA_GameMode = 19
|
|
DOTA_GameMode_DOTA_GAMEMODE_ARDM DOTA_GameMode = 20
|
|
DOTA_GameMode_DOTA_GAMEMODE_1V1MID DOTA_GameMode = 21
|
|
DOTA_GameMode_DOTA_GAMEMODE_ALL_DRAFT DOTA_GameMode = 22
|
|
)
|
|
|
|
var DOTA_GameMode_name = map[int32]string{
|
|
0: "DOTA_GAMEMODE_NONE",
|
|
1: "DOTA_GAMEMODE_AP",
|
|
2: "DOTA_GAMEMODE_CM",
|
|
3: "DOTA_GAMEMODE_RD",
|
|
4: "DOTA_GAMEMODE_SD",
|
|
5: "DOTA_GAMEMODE_AR",
|
|
6: "DOTA_GAMEMODE_INTRO",
|
|
7: "DOTA_GAMEMODE_HW",
|
|
8: "DOTA_GAMEMODE_REVERSE_CM",
|
|
9: "DOTA_GAMEMODE_XMAS",
|
|
10: "DOTA_GAMEMODE_TUTORIAL",
|
|
11: "DOTA_GAMEMODE_MO",
|
|
12: "DOTA_GAMEMODE_LP",
|
|
13: "DOTA_GAMEMODE_POOL1",
|
|
14: "DOTA_GAMEMODE_FH",
|
|
15: "DOTA_GAMEMODE_CUSTOM",
|
|
16: "DOTA_GAMEMODE_CD",
|
|
17: "DOTA_GAMEMODE_BD",
|
|
18: "DOTA_GAMEMODE_ABILITY_DRAFT",
|
|
19: "DOTA_GAMEMODE_EVENT",
|
|
20: "DOTA_GAMEMODE_ARDM",
|
|
21: "DOTA_GAMEMODE_1V1MID",
|
|
22: "DOTA_GAMEMODE_ALL_DRAFT",
|
|
}
|
|
var DOTA_GameMode_value = map[string]int32{
|
|
"DOTA_GAMEMODE_NONE": 0,
|
|
"DOTA_GAMEMODE_AP": 1,
|
|
"DOTA_GAMEMODE_CM": 2,
|
|
"DOTA_GAMEMODE_RD": 3,
|
|
"DOTA_GAMEMODE_SD": 4,
|
|
"DOTA_GAMEMODE_AR": 5,
|
|
"DOTA_GAMEMODE_INTRO": 6,
|
|
"DOTA_GAMEMODE_HW": 7,
|
|
"DOTA_GAMEMODE_REVERSE_CM": 8,
|
|
"DOTA_GAMEMODE_XMAS": 9,
|
|
"DOTA_GAMEMODE_TUTORIAL": 10,
|
|
"DOTA_GAMEMODE_MO": 11,
|
|
"DOTA_GAMEMODE_LP": 12,
|
|
"DOTA_GAMEMODE_POOL1": 13,
|
|
"DOTA_GAMEMODE_FH": 14,
|
|
"DOTA_GAMEMODE_CUSTOM": 15,
|
|
"DOTA_GAMEMODE_CD": 16,
|
|
"DOTA_GAMEMODE_BD": 17,
|
|
"DOTA_GAMEMODE_ABILITY_DRAFT": 18,
|
|
"DOTA_GAMEMODE_EVENT": 19,
|
|
"DOTA_GAMEMODE_ARDM": 20,
|
|
"DOTA_GAMEMODE_1V1MID": 21,
|
|
"DOTA_GAMEMODE_ALL_DRAFT": 22,
|
|
}
|
|
|
|
func (x DOTA_GameMode) Enum() *DOTA_GameMode {
|
|
p := new(DOTA_GameMode)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x DOTA_GameMode) String() string {
|
|
return proto.EnumName(DOTA_GameMode_name, int32(x))
|
|
}
|
|
func (x *DOTA_GameMode) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(DOTA_GameMode_value, data, "DOTA_GameMode")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = DOTA_GameMode(value)
|
|
return nil
|
|
}
|
|
func (DOTA_GameMode) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{0} }
|
|
|
|
type DOTA_GameState int32
|
|
|
|
const (
|
|
DOTA_GameState_DOTA_GAMERULES_STATE_INIT DOTA_GameState = 0
|
|
DOTA_GameState_DOTA_GAMERULES_STATE_WAIT_FOR_PLAYERS_TO_LOAD DOTA_GameState = 1
|
|
DOTA_GameState_DOTA_GAMERULES_STATE_HERO_SELECTION DOTA_GameState = 2
|
|
DOTA_GameState_DOTA_GAMERULES_STATE_STRATEGY_TIME DOTA_GameState = 3
|
|
DOTA_GameState_DOTA_GAMERULES_STATE_PRE_GAME DOTA_GameState = 4
|
|
DOTA_GameState_DOTA_GAMERULES_STATE_GAME_IN_PROGRESS DOTA_GameState = 5
|
|
DOTA_GameState_DOTA_GAMERULES_STATE_POST_GAME DOTA_GameState = 6
|
|
DOTA_GameState_DOTA_GAMERULES_STATE_DISCONNECT DOTA_GameState = 7
|
|
DOTA_GameState_DOTA_GAMERULES_STATE_TEAM_SHOWCASE DOTA_GameState = 8
|
|
DOTA_GameState_DOTA_GAMERULES_STATE_CUSTOM_GAME_SETUP DOTA_GameState = 9
|
|
DOTA_GameState_DOTA_GAMERULES_STATE_LAST DOTA_GameState = 10
|
|
)
|
|
|
|
var DOTA_GameState_name = map[int32]string{
|
|
0: "DOTA_GAMERULES_STATE_INIT",
|
|
1: "DOTA_GAMERULES_STATE_WAIT_FOR_PLAYERS_TO_LOAD",
|
|
2: "DOTA_GAMERULES_STATE_HERO_SELECTION",
|
|
3: "DOTA_GAMERULES_STATE_STRATEGY_TIME",
|
|
4: "DOTA_GAMERULES_STATE_PRE_GAME",
|
|
5: "DOTA_GAMERULES_STATE_GAME_IN_PROGRESS",
|
|
6: "DOTA_GAMERULES_STATE_POST_GAME",
|
|
7: "DOTA_GAMERULES_STATE_DISCONNECT",
|
|
8: "DOTA_GAMERULES_STATE_TEAM_SHOWCASE",
|
|
9: "DOTA_GAMERULES_STATE_CUSTOM_GAME_SETUP",
|
|
10: "DOTA_GAMERULES_STATE_LAST",
|
|
}
|
|
var DOTA_GameState_value = map[string]int32{
|
|
"DOTA_GAMERULES_STATE_INIT": 0,
|
|
"DOTA_GAMERULES_STATE_WAIT_FOR_PLAYERS_TO_LOAD": 1,
|
|
"DOTA_GAMERULES_STATE_HERO_SELECTION": 2,
|
|
"DOTA_GAMERULES_STATE_STRATEGY_TIME": 3,
|
|
"DOTA_GAMERULES_STATE_PRE_GAME": 4,
|
|
"DOTA_GAMERULES_STATE_GAME_IN_PROGRESS": 5,
|
|
"DOTA_GAMERULES_STATE_POST_GAME": 6,
|
|
"DOTA_GAMERULES_STATE_DISCONNECT": 7,
|
|
"DOTA_GAMERULES_STATE_TEAM_SHOWCASE": 8,
|
|
"DOTA_GAMERULES_STATE_CUSTOM_GAME_SETUP": 9,
|
|
"DOTA_GAMERULES_STATE_LAST": 10,
|
|
}
|
|
|
|
func (x DOTA_GameState) Enum() *DOTA_GameState {
|
|
p := new(DOTA_GameState)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x DOTA_GameState) String() string {
|
|
return proto.EnumName(DOTA_GameState_name, int32(x))
|
|
}
|
|
func (x *DOTA_GameState) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(DOTA_GameState_value, data, "DOTA_GameState")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = DOTA_GameState(value)
|
|
return nil
|
|
}
|
|
func (DOTA_GameState) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{1} }
|
|
|
|
type DOTA_GC_TEAM int32
|
|
|
|
const (
|
|
DOTA_GC_TEAM_DOTA_GC_TEAM_GOOD_GUYS DOTA_GC_TEAM = 0
|
|
DOTA_GC_TEAM_DOTA_GC_TEAM_BAD_GUYS DOTA_GC_TEAM = 1
|
|
DOTA_GC_TEAM_DOTA_GC_TEAM_BROADCASTER DOTA_GC_TEAM = 2
|
|
DOTA_GC_TEAM_DOTA_GC_TEAM_SPECTATOR DOTA_GC_TEAM = 3
|
|
DOTA_GC_TEAM_DOTA_GC_TEAM_PLAYER_POOL DOTA_GC_TEAM = 4
|
|
DOTA_GC_TEAM_DOTA_GC_TEAM_NOTEAM DOTA_GC_TEAM = 5
|
|
)
|
|
|
|
var DOTA_GC_TEAM_name = map[int32]string{
|
|
0: "DOTA_GC_TEAM_GOOD_GUYS",
|
|
1: "DOTA_GC_TEAM_BAD_GUYS",
|
|
2: "DOTA_GC_TEAM_BROADCASTER",
|
|
3: "DOTA_GC_TEAM_SPECTATOR",
|
|
4: "DOTA_GC_TEAM_PLAYER_POOL",
|
|
5: "DOTA_GC_TEAM_NOTEAM",
|
|
}
|
|
var DOTA_GC_TEAM_value = map[string]int32{
|
|
"DOTA_GC_TEAM_GOOD_GUYS": 0,
|
|
"DOTA_GC_TEAM_BAD_GUYS": 1,
|
|
"DOTA_GC_TEAM_BROADCASTER": 2,
|
|
"DOTA_GC_TEAM_SPECTATOR": 3,
|
|
"DOTA_GC_TEAM_PLAYER_POOL": 4,
|
|
"DOTA_GC_TEAM_NOTEAM": 5,
|
|
}
|
|
|
|
func (x DOTA_GC_TEAM) Enum() *DOTA_GC_TEAM {
|
|
p := new(DOTA_GC_TEAM)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x DOTA_GC_TEAM) String() string {
|
|
return proto.EnumName(DOTA_GC_TEAM_name, int32(x))
|
|
}
|
|
func (x *DOTA_GC_TEAM) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(DOTA_GC_TEAM_value, data, "DOTA_GC_TEAM")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = DOTA_GC_TEAM(value)
|
|
return nil
|
|
}
|
|
func (DOTA_GC_TEAM) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{2} }
|
|
|
|
type EEvent int32
|
|
|
|
const (
|
|
EEvent_EVENT_ID_NONE EEvent = 0
|
|
EEvent_EVENT_ID_DIRETIDE EEvent = 1
|
|
EEvent_EVENT_ID_SPRING_FESTIVAL EEvent = 2
|
|
EEvent_EVENT_ID_FROSTIVUS_2013 EEvent = 3
|
|
EEvent_EVENT_ID_COMPENDIUM_2014 EEvent = 4
|
|
EEvent_EVENT_ID_NEXON_PC_BANG EEvent = 5
|
|
EEvent_EVENT_ID_PWRD_DAC_2015 EEvent = 6
|
|
EEvent_EVENT_ID_NEW_BLOOM_2015 EEvent = 7
|
|
EEvent_EVENT_ID_INTERNATIONAL_2015 EEvent = 8
|
|
EEvent_EVENT_ID_FALL_MAJOR_2015 EEvent = 9
|
|
EEvent_EVENT_ID_ORACLE_PA EEvent = 10
|
|
EEvent_EVENT_ID_NEW_BLOOM_2015_PREBEAST EEvent = 11
|
|
EEvent_EVENT_ID_FROSTIVUS EEvent = 12
|
|
EEvent_EVENT_ID_WINTER_MAJOR_2016 EEvent = 13
|
|
EEvent_EVENT_ID_INTERNATIONAL_2016 EEvent = 14
|
|
)
|
|
|
|
var EEvent_name = map[int32]string{
|
|
0: "EVENT_ID_NONE",
|
|
1: "EVENT_ID_DIRETIDE",
|
|
2: "EVENT_ID_SPRING_FESTIVAL",
|
|
3: "EVENT_ID_FROSTIVUS_2013",
|
|
4: "EVENT_ID_COMPENDIUM_2014",
|
|
5: "EVENT_ID_NEXON_PC_BANG",
|
|
6: "EVENT_ID_PWRD_DAC_2015",
|
|
7: "EVENT_ID_NEW_BLOOM_2015",
|
|
8: "EVENT_ID_INTERNATIONAL_2015",
|
|
9: "EVENT_ID_FALL_MAJOR_2015",
|
|
10: "EVENT_ID_ORACLE_PA",
|
|
11: "EVENT_ID_NEW_BLOOM_2015_PREBEAST",
|
|
12: "EVENT_ID_FROSTIVUS",
|
|
13: "EVENT_ID_WINTER_MAJOR_2016",
|
|
14: "EVENT_ID_INTERNATIONAL_2016",
|
|
}
|
|
var EEvent_value = map[string]int32{
|
|
"EVENT_ID_NONE": 0,
|
|
"EVENT_ID_DIRETIDE": 1,
|
|
"EVENT_ID_SPRING_FESTIVAL": 2,
|
|
"EVENT_ID_FROSTIVUS_2013": 3,
|
|
"EVENT_ID_COMPENDIUM_2014": 4,
|
|
"EVENT_ID_NEXON_PC_BANG": 5,
|
|
"EVENT_ID_PWRD_DAC_2015": 6,
|
|
"EVENT_ID_NEW_BLOOM_2015": 7,
|
|
"EVENT_ID_INTERNATIONAL_2015": 8,
|
|
"EVENT_ID_FALL_MAJOR_2015": 9,
|
|
"EVENT_ID_ORACLE_PA": 10,
|
|
"EVENT_ID_NEW_BLOOM_2015_PREBEAST": 11,
|
|
"EVENT_ID_FROSTIVUS": 12,
|
|
"EVENT_ID_WINTER_MAJOR_2016": 13,
|
|
"EVENT_ID_INTERNATIONAL_2016": 14,
|
|
}
|
|
|
|
func (x EEvent) Enum() *EEvent {
|
|
p := new(EEvent)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x EEvent) String() string {
|
|
return proto.EnumName(EEvent_name, int32(x))
|
|
}
|
|
func (x *EEvent) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(EEvent_value, data, "EEvent")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = EEvent(value)
|
|
return nil
|
|
}
|
|
func (EEvent) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{3} }
|
|
|
|
type DOTALeaverStatusT int32
|
|
|
|
const (
|
|
DOTALeaverStatusT_DOTA_LEAVER_NONE DOTALeaverStatusT = 0
|
|
DOTALeaverStatusT_DOTA_LEAVER_DISCONNECTED DOTALeaverStatusT = 1
|
|
DOTALeaverStatusT_DOTA_LEAVER_DISCONNECTED_TOO_LONG DOTALeaverStatusT = 2
|
|
DOTALeaverStatusT_DOTA_LEAVER_ABANDONED DOTALeaverStatusT = 3
|
|
DOTALeaverStatusT_DOTA_LEAVER_AFK DOTALeaverStatusT = 4
|
|
DOTALeaverStatusT_DOTA_LEAVER_NEVER_CONNECTED DOTALeaverStatusT = 5
|
|
DOTALeaverStatusT_DOTA_LEAVER_NEVER_CONNECTED_TOO_LONG DOTALeaverStatusT = 6
|
|
DOTALeaverStatusT_DOTA_LEAVER_FAILED_TO_READY_UP DOTALeaverStatusT = 7
|
|
DOTALeaverStatusT_DOTA_LEAVER_DECLINED DOTALeaverStatusT = 8
|
|
)
|
|
|
|
var DOTALeaverStatusT_name = map[int32]string{
|
|
0: "DOTA_LEAVER_NONE",
|
|
1: "DOTA_LEAVER_DISCONNECTED",
|
|
2: "DOTA_LEAVER_DISCONNECTED_TOO_LONG",
|
|
3: "DOTA_LEAVER_ABANDONED",
|
|
4: "DOTA_LEAVER_AFK",
|
|
5: "DOTA_LEAVER_NEVER_CONNECTED",
|
|
6: "DOTA_LEAVER_NEVER_CONNECTED_TOO_LONG",
|
|
7: "DOTA_LEAVER_FAILED_TO_READY_UP",
|
|
8: "DOTA_LEAVER_DECLINED",
|
|
}
|
|
var DOTALeaverStatusT_value = map[string]int32{
|
|
"DOTA_LEAVER_NONE": 0,
|
|
"DOTA_LEAVER_DISCONNECTED": 1,
|
|
"DOTA_LEAVER_DISCONNECTED_TOO_LONG": 2,
|
|
"DOTA_LEAVER_ABANDONED": 3,
|
|
"DOTA_LEAVER_AFK": 4,
|
|
"DOTA_LEAVER_NEVER_CONNECTED": 5,
|
|
"DOTA_LEAVER_NEVER_CONNECTED_TOO_LONG": 6,
|
|
"DOTA_LEAVER_FAILED_TO_READY_UP": 7,
|
|
"DOTA_LEAVER_DECLINED": 8,
|
|
}
|
|
|
|
func (x DOTALeaverStatusT) Enum() *DOTALeaverStatusT {
|
|
p := new(DOTALeaverStatusT)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x DOTALeaverStatusT) String() string {
|
|
return proto.EnumName(DOTALeaverStatusT_name, int32(x))
|
|
}
|
|
func (x *DOTALeaverStatusT) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(DOTALeaverStatusT_value, data, "DOTALeaverStatusT")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = DOTALeaverStatusT(value)
|
|
return nil
|
|
}
|
|
func (DOTALeaverStatusT) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{4} }
|
|
|
|
type DOTAConnectionStateT int32
|
|
|
|
const (
|
|
DOTAConnectionStateT_DOTA_CONNECTION_STATE_UNKNOWN DOTAConnectionStateT = 0
|
|
DOTAConnectionStateT_DOTA_CONNECTION_STATE_NOT_YET_CONNECTED DOTAConnectionStateT = 1
|
|
DOTAConnectionStateT_DOTA_CONNECTION_STATE_CONNECTED DOTAConnectionStateT = 2
|
|
DOTAConnectionStateT_DOTA_CONNECTION_STATE_DISCONNECTED DOTAConnectionStateT = 3
|
|
DOTAConnectionStateT_DOTA_CONNECTION_STATE_ABANDONED DOTAConnectionStateT = 4
|
|
DOTAConnectionStateT_DOTA_CONNECTION_STATE_LOADING DOTAConnectionStateT = 5
|
|
DOTAConnectionStateT_DOTA_CONNECTION_STATE_FAILED DOTAConnectionStateT = 6
|
|
)
|
|
|
|
var DOTAConnectionStateT_name = map[int32]string{
|
|
0: "DOTA_CONNECTION_STATE_UNKNOWN",
|
|
1: "DOTA_CONNECTION_STATE_NOT_YET_CONNECTED",
|
|
2: "DOTA_CONNECTION_STATE_CONNECTED",
|
|
3: "DOTA_CONNECTION_STATE_DISCONNECTED",
|
|
4: "DOTA_CONNECTION_STATE_ABANDONED",
|
|
5: "DOTA_CONNECTION_STATE_LOADING",
|
|
6: "DOTA_CONNECTION_STATE_FAILED",
|
|
}
|
|
var DOTAConnectionStateT_value = map[string]int32{
|
|
"DOTA_CONNECTION_STATE_UNKNOWN": 0,
|
|
"DOTA_CONNECTION_STATE_NOT_YET_CONNECTED": 1,
|
|
"DOTA_CONNECTION_STATE_CONNECTED": 2,
|
|
"DOTA_CONNECTION_STATE_DISCONNECTED": 3,
|
|
"DOTA_CONNECTION_STATE_ABANDONED": 4,
|
|
"DOTA_CONNECTION_STATE_LOADING": 5,
|
|
"DOTA_CONNECTION_STATE_FAILED": 6,
|
|
}
|
|
|
|
func (x DOTAConnectionStateT) Enum() *DOTAConnectionStateT {
|
|
p := new(DOTAConnectionStateT)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x DOTAConnectionStateT) String() string {
|
|
return proto.EnumName(DOTAConnectionStateT_name, int32(x))
|
|
}
|
|
func (x *DOTAConnectionStateT) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(DOTAConnectionStateT_value, data, "DOTAConnectionStateT")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = DOTAConnectionStateT(value)
|
|
return nil
|
|
}
|
|
func (DOTAConnectionStateT) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{5} }
|
|
|
|
type Fantasy_Roles int32
|
|
|
|
const (
|
|
Fantasy_Roles_FANTASY_ROLE_UNDEFINED Fantasy_Roles = 0
|
|
Fantasy_Roles_FANTASY_ROLE_CORE Fantasy_Roles = 1
|
|
Fantasy_Roles_FANTASY_ROLE_SUPPORT Fantasy_Roles = 2
|
|
)
|
|
|
|
var Fantasy_Roles_name = map[int32]string{
|
|
0: "FANTASY_ROLE_UNDEFINED",
|
|
1: "FANTASY_ROLE_CORE",
|
|
2: "FANTASY_ROLE_SUPPORT",
|
|
}
|
|
var Fantasy_Roles_value = map[string]int32{
|
|
"FANTASY_ROLE_UNDEFINED": 0,
|
|
"FANTASY_ROLE_CORE": 1,
|
|
"FANTASY_ROLE_SUPPORT": 2,
|
|
}
|
|
|
|
func (x Fantasy_Roles) Enum() *Fantasy_Roles {
|
|
p := new(Fantasy_Roles)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x Fantasy_Roles) String() string {
|
|
return proto.EnumName(Fantasy_Roles_name, int32(x))
|
|
}
|
|
func (x *Fantasy_Roles) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(Fantasy_Roles_value, data, "Fantasy_Roles")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = Fantasy_Roles(value)
|
|
return nil
|
|
}
|
|
func (Fantasy_Roles) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{6} }
|
|
|
|
type Fantasy_Team_Slots int32
|
|
|
|
const (
|
|
Fantasy_Team_Slots_FANTASY_SLOT_NONE Fantasy_Team_Slots = 0
|
|
Fantasy_Team_Slots_FANTASY_SLOT_CORE Fantasy_Team_Slots = 1
|
|
Fantasy_Team_Slots_FANTASY_SLOT_SUPPORT Fantasy_Team_Slots = 2
|
|
Fantasy_Team_Slots_FANTASY_SLOT_ANY Fantasy_Team_Slots = 3
|
|
Fantasy_Team_Slots_FANTASY_SLOT_BENCH Fantasy_Team_Slots = 4
|
|
)
|
|
|
|
var Fantasy_Team_Slots_name = map[int32]string{
|
|
0: "FANTASY_SLOT_NONE",
|
|
1: "FANTASY_SLOT_CORE",
|
|
2: "FANTASY_SLOT_SUPPORT",
|
|
3: "FANTASY_SLOT_ANY",
|
|
4: "FANTASY_SLOT_BENCH",
|
|
}
|
|
var Fantasy_Team_Slots_value = map[string]int32{
|
|
"FANTASY_SLOT_NONE": 0,
|
|
"FANTASY_SLOT_CORE": 1,
|
|
"FANTASY_SLOT_SUPPORT": 2,
|
|
"FANTASY_SLOT_ANY": 3,
|
|
"FANTASY_SLOT_BENCH": 4,
|
|
}
|
|
|
|
func (x Fantasy_Team_Slots) Enum() *Fantasy_Team_Slots {
|
|
p := new(Fantasy_Team_Slots)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x Fantasy_Team_Slots) String() string {
|
|
return proto.EnumName(Fantasy_Team_Slots_name, int32(x))
|
|
}
|
|
func (x *Fantasy_Team_Slots) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(Fantasy_Team_Slots_value, data, "Fantasy_Team_Slots")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = Fantasy_Team_Slots(value)
|
|
return nil
|
|
}
|
|
func (Fantasy_Team_Slots) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{7} }
|
|
|
|
type Fantasy_Selection_Mode int32
|
|
|
|
const (
|
|
Fantasy_Selection_Mode_FANTASY_SELECTION_INVALID Fantasy_Selection_Mode = 0
|
|
Fantasy_Selection_Mode_FANTASY_SELECTION_LOCKED Fantasy_Selection_Mode = 1
|
|
Fantasy_Selection_Mode_FANTASY_SELECTION_SHUFFLE Fantasy_Selection_Mode = 2
|
|
Fantasy_Selection_Mode_FANTASY_SELECTION_FREE_PICK Fantasy_Selection_Mode = 3
|
|
Fantasy_Selection_Mode_FANTASY_SELECTION_ENDED Fantasy_Selection_Mode = 4
|
|
Fantasy_Selection_Mode_FANTASY_SELECTION_PRE_SEASON Fantasy_Selection_Mode = 5
|
|
Fantasy_Selection_Mode_FANTASY_SELECTION_PRE_DRAFT Fantasy_Selection_Mode = 6
|
|
Fantasy_Selection_Mode_FANTASY_SELECTION_DRAFTING Fantasy_Selection_Mode = 7
|
|
Fantasy_Selection_Mode_FANTASY_SELECTION_REGULAR_SEASON Fantasy_Selection_Mode = 8
|
|
Fantasy_Selection_Mode_FANTASY_SELECTION_CARD_BASED Fantasy_Selection_Mode = 9
|
|
)
|
|
|
|
var Fantasy_Selection_Mode_name = map[int32]string{
|
|
0: "FANTASY_SELECTION_INVALID",
|
|
1: "FANTASY_SELECTION_LOCKED",
|
|
2: "FANTASY_SELECTION_SHUFFLE",
|
|
3: "FANTASY_SELECTION_FREE_PICK",
|
|
4: "FANTASY_SELECTION_ENDED",
|
|
5: "FANTASY_SELECTION_PRE_SEASON",
|
|
6: "FANTASY_SELECTION_PRE_DRAFT",
|
|
7: "FANTASY_SELECTION_DRAFTING",
|
|
8: "FANTASY_SELECTION_REGULAR_SEASON",
|
|
9: "FANTASY_SELECTION_CARD_BASED",
|
|
}
|
|
var Fantasy_Selection_Mode_value = map[string]int32{
|
|
"FANTASY_SELECTION_INVALID": 0,
|
|
"FANTASY_SELECTION_LOCKED": 1,
|
|
"FANTASY_SELECTION_SHUFFLE": 2,
|
|
"FANTASY_SELECTION_FREE_PICK": 3,
|
|
"FANTASY_SELECTION_ENDED": 4,
|
|
"FANTASY_SELECTION_PRE_SEASON": 5,
|
|
"FANTASY_SELECTION_PRE_DRAFT": 6,
|
|
"FANTASY_SELECTION_DRAFTING": 7,
|
|
"FANTASY_SELECTION_REGULAR_SEASON": 8,
|
|
"FANTASY_SELECTION_CARD_BASED": 9,
|
|
}
|
|
|
|
func (x Fantasy_Selection_Mode) Enum() *Fantasy_Selection_Mode {
|
|
p := new(Fantasy_Selection_Mode)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x Fantasy_Selection_Mode) String() string {
|
|
return proto.EnumName(Fantasy_Selection_Mode_name, int32(x))
|
|
}
|
|
func (x *Fantasy_Selection_Mode) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(Fantasy_Selection_Mode_value, data, "Fantasy_Selection_Mode")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = Fantasy_Selection_Mode(value)
|
|
return nil
|
|
}
|
|
func (Fantasy_Selection_Mode) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{8} }
|
|
|
|
type DOTAChatChannelTypeT int32
|
|
|
|
const (
|
|
DOTAChatChannelTypeT_DOTAChannelType_Regional DOTAChatChannelTypeT = 0
|
|
DOTAChatChannelTypeT_DOTAChannelType_Custom DOTAChatChannelTypeT = 1
|
|
DOTAChatChannelTypeT_DOTAChannelType_Party DOTAChatChannelTypeT = 2
|
|
DOTAChatChannelTypeT_DOTAChannelType_Lobby DOTAChatChannelTypeT = 3
|
|
DOTAChatChannelTypeT_DOTAChannelType_Team DOTAChatChannelTypeT = 4
|
|
DOTAChatChannelTypeT_DOTAChannelType_Guild DOTAChatChannelTypeT = 5
|
|
DOTAChatChannelTypeT_DOTAChannelType_Fantasy DOTAChatChannelTypeT = 6
|
|
DOTAChatChannelTypeT_DOTAChannelType_Whisper DOTAChatChannelTypeT = 7
|
|
DOTAChatChannelTypeT_DOTAChannelType_Console DOTAChatChannelTypeT = 8
|
|
DOTAChatChannelTypeT_DOTAChannelType_Tab DOTAChatChannelTypeT = 9
|
|
DOTAChatChannelTypeT_DOTAChannelType_Invalid DOTAChatChannelTypeT = 10
|
|
DOTAChatChannelTypeT_DOTAChannelType_GameAll DOTAChatChannelTypeT = 11
|
|
DOTAChatChannelTypeT_DOTAChannelType_GameAllies DOTAChatChannelTypeT = 12
|
|
DOTAChatChannelTypeT_DOTAChannelType_GameSpectator DOTAChatChannelTypeT = 13
|
|
DOTAChatChannelTypeT_DOTAChannelType_GameCoaching DOTAChatChannelTypeT = 14
|
|
DOTAChatChannelTypeT_DOTAChannelType_Cafe DOTAChatChannelTypeT = 15
|
|
DOTAChatChannelTypeT_DOTAChannelType_CustomGame DOTAChatChannelTypeT = 16
|
|
DOTAChatChannelTypeT_DOTAChannelType_Private DOTAChatChannelTypeT = 17
|
|
DOTAChatChannelTypeT_DOTAChannelType_PostGame DOTAChatChannelTypeT = 18
|
|
DOTAChatChannelTypeT_DOTAChannelType_BattleCup DOTAChatChannelTypeT = 19
|
|
DOTAChatChannelTypeT_DOTAChannelType_HLTVSpectator DOTAChatChannelTypeT = 20
|
|
)
|
|
|
|
var DOTAChatChannelTypeT_name = map[int32]string{
|
|
0: "DOTAChannelType_Regional",
|
|
1: "DOTAChannelType_Custom",
|
|
2: "DOTAChannelType_Party",
|
|
3: "DOTAChannelType_Lobby",
|
|
4: "DOTAChannelType_Team",
|
|
5: "DOTAChannelType_Guild",
|
|
6: "DOTAChannelType_Fantasy",
|
|
7: "DOTAChannelType_Whisper",
|
|
8: "DOTAChannelType_Console",
|
|
9: "DOTAChannelType_Tab",
|
|
10: "DOTAChannelType_Invalid",
|
|
11: "DOTAChannelType_GameAll",
|
|
12: "DOTAChannelType_GameAllies",
|
|
13: "DOTAChannelType_GameSpectator",
|
|
14: "DOTAChannelType_GameCoaching",
|
|
15: "DOTAChannelType_Cafe",
|
|
16: "DOTAChannelType_CustomGame",
|
|
17: "DOTAChannelType_Private",
|
|
18: "DOTAChannelType_PostGame",
|
|
19: "DOTAChannelType_BattleCup",
|
|
20: "DOTAChannelType_HLTVSpectator",
|
|
}
|
|
var DOTAChatChannelTypeT_value = map[string]int32{
|
|
"DOTAChannelType_Regional": 0,
|
|
"DOTAChannelType_Custom": 1,
|
|
"DOTAChannelType_Party": 2,
|
|
"DOTAChannelType_Lobby": 3,
|
|
"DOTAChannelType_Team": 4,
|
|
"DOTAChannelType_Guild": 5,
|
|
"DOTAChannelType_Fantasy": 6,
|
|
"DOTAChannelType_Whisper": 7,
|
|
"DOTAChannelType_Console": 8,
|
|
"DOTAChannelType_Tab": 9,
|
|
"DOTAChannelType_Invalid": 10,
|
|
"DOTAChannelType_GameAll": 11,
|
|
"DOTAChannelType_GameAllies": 12,
|
|
"DOTAChannelType_GameSpectator": 13,
|
|
"DOTAChannelType_GameCoaching": 14,
|
|
"DOTAChannelType_Cafe": 15,
|
|
"DOTAChannelType_CustomGame": 16,
|
|
"DOTAChannelType_Private": 17,
|
|
"DOTAChannelType_PostGame": 18,
|
|
"DOTAChannelType_BattleCup": 19,
|
|
"DOTAChannelType_HLTVSpectator": 20,
|
|
}
|
|
|
|
func (x DOTAChatChannelTypeT) Enum() *DOTAChatChannelTypeT {
|
|
p := new(DOTAChatChannelTypeT)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x DOTAChatChannelTypeT) String() string {
|
|
return proto.EnumName(DOTAChatChannelTypeT_name, int32(x))
|
|
}
|
|
func (x *DOTAChatChannelTypeT) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(DOTAChatChannelTypeT_value, data, "DOTAChatChannelTypeT")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = DOTAChatChannelTypeT(value)
|
|
return nil
|
|
}
|
|
func (DOTAChatChannelTypeT) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{9} }
|
|
|
|
type EProfileCardSlotType int32
|
|
|
|
const (
|
|
EProfileCardSlotType_k_EProfileCardSlotType_Empty EProfileCardSlotType = 0
|
|
EProfileCardSlotType_k_EProfileCardSlotType_Stat EProfileCardSlotType = 1
|
|
EProfileCardSlotType_k_EProfileCardSlotType_Trophy EProfileCardSlotType = 2
|
|
EProfileCardSlotType_k_EProfileCardSlotType_Item EProfileCardSlotType = 3
|
|
EProfileCardSlotType_k_EProfileCardSlotType_Hero EProfileCardSlotType = 4
|
|
EProfileCardSlotType_k_EProfileCardSlotType_Emoticon EProfileCardSlotType = 5
|
|
)
|
|
|
|
var EProfileCardSlotType_name = map[int32]string{
|
|
0: "k_EProfileCardSlotType_Empty",
|
|
1: "k_EProfileCardSlotType_Stat",
|
|
2: "k_EProfileCardSlotType_Trophy",
|
|
3: "k_EProfileCardSlotType_Item",
|
|
4: "k_EProfileCardSlotType_Hero",
|
|
5: "k_EProfileCardSlotType_Emoticon",
|
|
}
|
|
var EProfileCardSlotType_value = map[string]int32{
|
|
"k_EProfileCardSlotType_Empty": 0,
|
|
"k_EProfileCardSlotType_Stat": 1,
|
|
"k_EProfileCardSlotType_Trophy": 2,
|
|
"k_EProfileCardSlotType_Item": 3,
|
|
"k_EProfileCardSlotType_Hero": 4,
|
|
"k_EProfileCardSlotType_Emoticon": 5,
|
|
}
|
|
|
|
func (x EProfileCardSlotType) Enum() *EProfileCardSlotType {
|
|
p := new(EProfileCardSlotType)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x EProfileCardSlotType) String() string {
|
|
return proto.EnumName(EProfileCardSlotType_name, int32(x))
|
|
}
|
|
func (x *EProfileCardSlotType) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(EProfileCardSlotType_value, data, "EProfileCardSlotType")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = EProfileCardSlotType(value)
|
|
return nil
|
|
}
|
|
func (EProfileCardSlotType) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{10} }
|
|
|
|
type EMatchGroupServerStatus int32
|
|
|
|
const (
|
|
EMatchGroupServerStatus_k_EMatchGroupServerStatus_OK EMatchGroupServerStatus = 0
|
|
EMatchGroupServerStatus_k_EMatchGroupServerStatus_LimitedAvailability EMatchGroupServerStatus = 1
|
|
EMatchGroupServerStatus_k_EMatchGroupServerStatus_Offline EMatchGroupServerStatus = 2
|
|
)
|
|
|
|
var EMatchGroupServerStatus_name = map[int32]string{
|
|
0: "k_EMatchGroupServerStatus_OK",
|
|
1: "k_EMatchGroupServerStatus_LimitedAvailability",
|
|
2: "k_EMatchGroupServerStatus_Offline",
|
|
}
|
|
var EMatchGroupServerStatus_value = map[string]int32{
|
|
"k_EMatchGroupServerStatus_OK": 0,
|
|
"k_EMatchGroupServerStatus_LimitedAvailability": 1,
|
|
"k_EMatchGroupServerStatus_Offline": 2,
|
|
}
|
|
|
|
func (x EMatchGroupServerStatus) Enum() *EMatchGroupServerStatus {
|
|
p := new(EMatchGroupServerStatus)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x EMatchGroupServerStatus) String() string {
|
|
return proto.EnumName(EMatchGroupServerStatus_name, int32(x))
|
|
}
|
|
func (x *EMatchGroupServerStatus) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(EMatchGroupServerStatus_value, data, "EMatchGroupServerStatus")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = EMatchGroupServerStatus(value)
|
|
return nil
|
|
}
|
|
func (EMatchGroupServerStatus) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{11} }
|
|
|
|
type DOTA_CM_PICK int32
|
|
|
|
const (
|
|
DOTA_CM_PICK_DOTA_CM_RANDOM DOTA_CM_PICK = 0
|
|
DOTA_CM_PICK_DOTA_CM_GOOD_GUYS DOTA_CM_PICK = 1
|
|
DOTA_CM_PICK_DOTA_CM_BAD_GUYS DOTA_CM_PICK = 2
|
|
)
|
|
|
|
var DOTA_CM_PICK_name = map[int32]string{
|
|
0: "DOTA_CM_RANDOM",
|
|
1: "DOTA_CM_GOOD_GUYS",
|
|
2: "DOTA_CM_BAD_GUYS",
|
|
}
|
|
var DOTA_CM_PICK_value = map[string]int32{
|
|
"DOTA_CM_RANDOM": 0,
|
|
"DOTA_CM_GOOD_GUYS": 1,
|
|
"DOTA_CM_BAD_GUYS": 2,
|
|
}
|
|
|
|
func (x DOTA_CM_PICK) Enum() *DOTA_CM_PICK {
|
|
p := new(DOTA_CM_PICK)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x DOTA_CM_PICK) String() string {
|
|
return proto.EnumName(DOTA_CM_PICK_name, int32(x))
|
|
}
|
|
func (x *DOTA_CM_PICK) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(DOTA_CM_PICK_value, data, "DOTA_CM_PICK")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = DOTA_CM_PICK(value)
|
|
return nil
|
|
}
|
|
func (DOTA_CM_PICK) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{12} }
|
|
|
|
type DOTALowPriorityBanType int32
|
|
|
|
const (
|
|
DOTALowPriorityBanType_DOTA_LOW_PRIORITY_BAN_ABANDON DOTALowPriorityBanType = 0
|
|
DOTALowPriorityBanType_DOTA_LOW_PRIORITY_BAN_REPORTS DOTALowPriorityBanType = 1
|
|
DOTALowPriorityBanType_DOTA_LOW_PRIORITY_BAN_SECONDARY_ABANDON DOTALowPriorityBanType = 2
|
|
)
|
|
|
|
var DOTALowPriorityBanType_name = map[int32]string{
|
|
0: "DOTA_LOW_PRIORITY_BAN_ABANDON",
|
|
1: "DOTA_LOW_PRIORITY_BAN_REPORTS",
|
|
2: "DOTA_LOW_PRIORITY_BAN_SECONDARY_ABANDON",
|
|
}
|
|
var DOTALowPriorityBanType_value = map[string]int32{
|
|
"DOTA_LOW_PRIORITY_BAN_ABANDON": 0,
|
|
"DOTA_LOW_PRIORITY_BAN_REPORTS": 1,
|
|
"DOTA_LOW_PRIORITY_BAN_SECONDARY_ABANDON": 2,
|
|
}
|
|
|
|
func (x DOTALowPriorityBanType) Enum() *DOTALowPriorityBanType {
|
|
p := new(DOTALowPriorityBanType)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x DOTALowPriorityBanType) String() string {
|
|
return proto.EnumName(DOTALowPriorityBanType_name, int32(x))
|
|
}
|
|
func (x *DOTALowPriorityBanType) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(DOTALowPriorityBanType_value, data, "DOTALowPriorityBanType")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = DOTALowPriorityBanType(value)
|
|
return nil
|
|
}
|
|
func (DOTALowPriorityBanType) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{13} }
|
|
|
|
type DOTALobbyReadyState int32
|
|
|
|
const (
|
|
DOTALobbyReadyState_DOTALobbyReadyState_UNDECLARED DOTALobbyReadyState = 0
|
|
DOTALobbyReadyState_DOTALobbyReadyState_ACCEPTED DOTALobbyReadyState = 1
|
|
DOTALobbyReadyState_DOTALobbyReadyState_DECLINED DOTALobbyReadyState = 2
|
|
)
|
|
|
|
var DOTALobbyReadyState_name = map[int32]string{
|
|
0: "DOTALobbyReadyState_UNDECLARED",
|
|
1: "DOTALobbyReadyState_ACCEPTED",
|
|
2: "DOTALobbyReadyState_DECLINED",
|
|
}
|
|
var DOTALobbyReadyState_value = map[string]int32{
|
|
"DOTALobbyReadyState_UNDECLARED": 0,
|
|
"DOTALobbyReadyState_ACCEPTED": 1,
|
|
"DOTALobbyReadyState_DECLINED": 2,
|
|
}
|
|
|
|
func (x DOTALobbyReadyState) Enum() *DOTALobbyReadyState {
|
|
p := new(DOTALobbyReadyState)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x DOTALobbyReadyState) String() string {
|
|
return proto.EnumName(DOTALobbyReadyState_name, int32(x))
|
|
}
|
|
func (x *DOTALobbyReadyState) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(DOTALobbyReadyState_value, data, "DOTALobbyReadyState")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = DOTALobbyReadyState(value)
|
|
return nil
|
|
}
|
|
func (DOTALobbyReadyState) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{14} }
|
|
|
|
type DOTAGameVersion int32
|
|
|
|
const (
|
|
DOTAGameVersion_GAME_VERSION_CURRENT DOTAGameVersion = 0
|
|
DOTAGameVersion_GAME_VERSION_STABLE DOTAGameVersion = 1
|
|
)
|
|
|
|
var DOTAGameVersion_name = map[int32]string{
|
|
0: "GAME_VERSION_CURRENT",
|
|
1: "GAME_VERSION_STABLE",
|
|
}
|
|
var DOTAGameVersion_value = map[string]int32{
|
|
"GAME_VERSION_CURRENT": 0,
|
|
"GAME_VERSION_STABLE": 1,
|
|
}
|
|
|
|
func (x DOTAGameVersion) Enum() *DOTAGameVersion {
|
|
p := new(DOTAGameVersion)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x DOTAGameVersion) String() string {
|
|
return proto.EnumName(DOTAGameVersion_name, int32(x))
|
|
}
|
|
func (x *DOTAGameVersion) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(DOTAGameVersion_value, data, "DOTAGameVersion")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = DOTAGameVersion(value)
|
|
return nil
|
|
}
|
|
func (DOTAGameVersion) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{15} }
|
|
|
|
type DOTAJoinLobbyResult int32
|
|
|
|
const (
|
|
DOTAJoinLobbyResult_DOTA_JOIN_RESULT_SUCCESS DOTAJoinLobbyResult = 0
|
|
DOTAJoinLobbyResult_DOTA_JOIN_RESULT_ALREADY_IN_GAME DOTAJoinLobbyResult = 1
|
|
DOTAJoinLobbyResult_DOTA_JOIN_RESULT_INVALID_LOBBY DOTAJoinLobbyResult = 2
|
|
DOTAJoinLobbyResult_DOTA_JOIN_RESULT_INCORRECT_PASSWORD DOTAJoinLobbyResult = 3
|
|
DOTAJoinLobbyResult_DOTA_JOIN_RESULT_ACCESS_DENIED DOTAJoinLobbyResult = 4
|
|
DOTAJoinLobbyResult_DOTA_JOIN_RESULT_GENERIC_ERROR DOTAJoinLobbyResult = 5
|
|
DOTAJoinLobbyResult_DOTA_JOIN_RESULT_INCORRECT_VERSION DOTAJoinLobbyResult = 6
|
|
DOTAJoinLobbyResult_DOTA_JOIN_RESULT_IN_TEAM_PARTY DOTAJoinLobbyResult = 7
|
|
DOTAJoinLobbyResult_DOTA_JOIN_RESULT_NO_LOBBY_FOUND DOTAJoinLobbyResult = 8
|
|
DOTAJoinLobbyResult_DOTA_JOIN_RESULT_LOBBY_FULL DOTAJoinLobbyResult = 9
|
|
DOTAJoinLobbyResult_DOTA_JOIN_RESULT_CUSTOM_GAME_INCORRECT_VERSION DOTAJoinLobbyResult = 10
|
|
DOTAJoinLobbyResult_DOTA_JOIN_RESULT_TIMEOUT DOTAJoinLobbyResult = 11
|
|
)
|
|
|
|
var DOTAJoinLobbyResult_name = map[int32]string{
|
|
0: "DOTA_JOIN_RESULT_SUCCESS",
|
|
1: "DOTA_JOIN_RESULT_ALREADY_IN_GAME",
|
|
2: "DOTA_JOIN_RESULT_INVALID_LOBBY",
|
|
3: "DOTA_JOIN_RESULT_INCORRECT_PASSWORD",
|
|
4: "DOTA_JOIN_RESULT_ACCESS_DENIED",
|
|
5: "DOTA_JOIN_RESULT_GENERIC_ERROR",
|
|
6: "DOTA_JOIN_RESULT_INCORRECT_VERSION",
|
|
7: "DOTA_JOIN_RESULT_IN_TEAM_PARTY",
|
|
8: "DOTA_JOIN_RESULT_NO_LOBBY_FOUND",
|
|
9: "DOTA_JOIN_RESULT_LOBBY_FULL",
|
|
10: "DOTA_JOIN_RESULT_CUSTOM_GAME_INCORRECT_VERSION",
|
|
11: "DOTA_JOIN_RESULT_TIMEOUT",
|
|
}
|
|
var DOTAJoinLobbyResult_value = map[string]int32{
|
|
"DOTA_JOIN_RESULT_SUCCESS": 0,
|
|
"DOTA_JOIN_RESULT_ALREADY_IN_GAME": 1,
|
|
"DOTA_JOIN_RESULT_INVALID_LOBBY": 2,
|
|
"DOTA_JOIN_RESULT_INCORRECT_PASSWORD": 3,
|
|
"DOTA_JOIN_RESULT_ACCESS_DENIED": 4,
|
|
"DOTA_JOIN_RESULT_GENERIC_ERROR": 5,
|
|
"DOTA_JOIN_RESULT_INCORRECT_VERSION": 6,
|
|
"DOTA_JOIN_RESULT_IN_TEAM_PARTY": 7,
|
|
"DOTA_JOIN_RESULT_NO_LOBBY_FOUND": 8,
|
|
"DOTA_JOIN_RESULT_LOBBY_FULL": 9,
|
|
"DOTA_JOIN_RESULT_CUSTOM_GAME_INCORRECT_VERSION": 10,
|
|
"DOTA_JOIN_RESULT_TIMEOUT": 11,
|
|
}
|
|
|
|
func (x DOTAJoinLobbyResult) Enum() *DOTAJoinLobbyResult {
|
|
p := new(DOTAJoinLobbyResult)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x DOTAJoinLobbyResult) String() string {
|
|
return proto.EnumName(DOTAJoinLobbyResult_name, int32(x))
|
|
}
|
|
func (x *DOTAJoinLobbyResult) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(DOTAJoinLobbyResult_value, data, "DOTAJoinLobbyResult")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = DOTAJoinLobbyResult(value)
|
|
return nil
|
|
}
|
|
func (DOTAJoinLobbyResult) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{16} }
|
|
|
|
type SelectionPriorityType int32
|
|
|
|
const (
|
|
SelectionPriorityType_UNDEFINED SelectionPriorityType = 0
|
|
SelectionPriorityType_RADIANT SelectionPriorityType = 1
|
|
SelectionPriorityType_DIRE SelectionPriorityType = 2
|
|
SelectionPriorityType_FIRST_PICK SelectionPriorityType = 3
|
|
SelectionPriorityType_SECOND_PICK SelectionPriorityType = 4
|
|
)
|
|
|
|
var SelectionPriorityType_name = map[int32]string{
|
|
0: "UNDEFINED",
|
|
1: "RADIANT",
|
|
2: "DIRE",
|
|
3: "FIRST_PICK",
|
|
4: "SECOND_PICK",
|
|
}
|
|
var SelectionPriorityType_value = map[string]int32{
|
|
"UNDEFINED": 0,
|
|
"RADIANT": 1,
|
|
"DIRE": 2,
|
|
"FIRST_PICK": 3,
|
|
"SECOND_PICK": 4,
|
|
}
|
|
|
|
func (x SelectionPriorityType) Enum() *SelectionPriorityType {
|
|
p := new(SelectionPriorityType)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x SelectionPriorityType) String() string {
|
|
return proto.EnumName(SelectionPriorityType_name, int32(x))
|
|
}
|
|
func (x *SelectionPriorityType) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(SelectionPriorityType_value, data, "SelectionPriorityType")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = SelectionPriorityType(value)
|
|
return nil
|
|
}
|
|
func (SelectionPriorityType) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{17} }
|
|
|
|
type DOTAMatchVote int32
|
|
|
|
const (
|
|
DOTAMatchVote_DOTAMatchVote_INVALID DOTAMatchVote = 0
|
|
DOTAMatchVote_DOTAMatchVote_POSITIVE DOTAMatchVote = 1
|
|
DOTAMatchVote_DOTAMatchVote_NEGATIVE DOTAMatchVote = 2
|
|
)
|
|
|
|
var DOTAMatchVote_name = map[int32]string{
|
|
0: "DOTAMatchVote_INVALID",
|
|
1: "DOTAMatchVote_POSITIVE",
|
|
2: "DOTAMatchVote_NEGATIVE",
|
|
}
|
|
var DOTAMatchVote_value = map[string]int32{
|
|
"DOTAMatchVote_INVALID": 0,
|
|
"DOTAMatchVote_POSITIVE": 1,
|
|
"DOTAMatchVote_NEGATIVE": 2,
|
|
}
|
|
|
|
func (x DOTAMatchVote) Enum() *DOTAMatchVote {
|
|
p := new(DOTAMatchVote)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x DOTAMatchVote) String() string {
|
|
return proto.EnumName(DOTAMatchVote_name, int32(x))
|
|
}
|
|
func (x *DOTAMatchVote) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(DOTAMatchVote_value, data, "DOTAMatchVote")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = DOTAMatchVote(value)
|
|
return nil
|
|
}
|
|
func (DOTAMatchVote) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{18} }
|
|
|
|
type DOTA_LobbyMemberXPBonus int32
|
|
|
|
const (
|
|
DOTA_LobbyMemberXPBonus_DOTA_LobbyMemberXPBonus_DEFAULT DOTA_LobbyMemberXPBonus = 0
|
|
DOTA_LobbyMemberXPBonus_DOTA_LobbyMemberXPBonus_BATTLE_BOOSTER DOTA_LobbyMemberXPBonus = 1
|
|
DOTA_LobbyMemberXPBonus_DOTA_LobbyMemberXPBonus_SHARE_BONUS DOTA_LobbyMemberXPBonus = 2
|
|
DOTA_LobbyMemberXPBonus_DOTA_LobbyMemberXPBonus_PARTY DOTA_LobbyMemberXPBonus = 3
|
|
DOTA_LobbyMemberXPBonus_DOTA_LobbyMemberXPBonus_RECRUITMENT DOTA_LobbyMemberXPBonus = 4
|
|
DOTA_LobbyMemberXPBonus_DOTA_LobbyMemberXPBonus_PCBANG DOTA_LobbyMemberXPBonus = 5
|
|
)
|
|
|
|
var DOTA_LobbyMemberXPBonus_name = map[int32]string{
|
|
0: "DOTA_LobbyMemberXPBonus_DEFAULT",
|
|
1: "DOTA_LobbyMemberXPBonus_BATTLE_BOOSTER",
|
|
2: "DOTA_LobbyMemberXPBonus_SHARE_BONUS",
|
|
3: "DOTA_LobbyMemberXPBonus_PARTY",
|
|
4: "DOTA_LobbyMemberXPBonus_RECRUITMENT",
|
|
5: "DOTA_LobbyMemberXPBonus_PCBANG",
|
|
}
|
|
var DOTA_LobbyMemberXPBonus_value = map[string]int32{
|
|
"DOTA_LobbyMemberXPBonus_DEFAULT": 0,
|
|
"DOTA_LobbyMemberXPBonus_BATTLE_BOOSTER": 1,
|
|
"DOTA_LobbyMemberXPBonus_SHARE_BONUS": 2,
|
|
"DOTA_LobbyMemberXPBonus_PARTY": 3,
|
|
"DOTA_LobbyMemberXPBonus_RECRUITMENT": 4,
|
|
"DOTA_LobbyMemberXPBonus_PCBANG": 5,
|
|
}
|
|
|
|
func (x DOTA_LobbyMemberXPBonus) Enum() *DOTA_LobbyMemberXPBonus {
|
|
p := new(DOTA_LobbyMemberXPBonus)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x DOTA_LobbyMemberXPBonus) String() string {
|
|
return proto.EnumName(DOTA_LobbyMemberXPBonus_name, int32(x))
|
|
}
|
|
func (x *DOTA_LobbyMemberXPBonus) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(DOTA_LobbyMemberXPBonus_value, data, "DOTA_LobbyMemberXPBonus")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = DOTA_LobbyMemberXPBonus(value)
|
|
return nil
|
|
}
|
|
func (DOTA_LobbyMemberXPBonus) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{19} }
|
|
|
|
type DOTALobbyVisibility int32
|
|
|
|
const (
|
|
DOTALobbyVisibility_DOTALobbyVisibility_Public DOTALobbyVisibility = 0
|
|
DOTALobbyVisibility_DOTALobbyVisibility_Friends DOTALobbyVisibility = 1
|
|
DOTALobbyVisibility_DOTALobbyVisibility_Unlisted DOTALobbyVisibility = 2
|
|
)
|
|
|
|
var DOTALobbyVisibility_name = map[int32]string{
|
|
0: "DOTALobbyVisibility_Public",
|
|
1: "DOTALobbyVisibility_Friends",
|
|
2: "DOTALobbyVisibility_Unlisted",
|
|
}
|
|
var DOTALobbyVisibility_value = map[string]int32{
|
|
"DOTALobbyVisibility_Public": 0,
|
|
"DOTALobbyVisibility_Friends": 1,
|
|
"DOTALobbyVisibility_Unlisted": 2,
|
|
}
|
|
|
|
func (x DOTALobbyVisibility) Enum() *DOTALobbyVisibility {
|
|
p := new(DOTALobbyVisibility)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x DOTALobbyVisibility) String() string {
|
|
return proto.EnumName(DOTALobbyVisibility_name, int32(x))
|
|
}
|
|
func (x *DOTALobbyVisibility) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(DOTALobbyVisibility_value, data, "DOTALobbyVisibility")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = DOTALobbyVisibility(value)
|
|
return nil
|
|
}
|
|
func (DOTALobbyVisibility) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{20} }
|
|
|
|
type EDOTAPlayerMMRType int32
|
|
|
|
const (
|
|
EDOTAPlayerMMRType_k_EDOTAPlayerMMRType_Invalid EDOTAPlayerMMRType = 0
|
|
EDOTAPlayerMMRType_k_EDOTAPlayerMMRType_GeneralHidden EDOTAPlayerMMRType = 1
|
|
EDOTAPlayerMMRType_k_EDOTAPlayerMMRType_SoloHidden EDOTAPlayerMMRType = 2
|
|
EDOTAPlayerMMRType_k_EDOTAPlayerMMRType_GeneralCompetitive EDOTAPlayerMMRType = 3
|
|
EDOTAPlayerMMRType_k_EDOTAPlayerMMRType_SoloCompetitive EDOTAPlayerMMRType = 4
|
|
EDOTAPlayerMMRType_k_EDOTAPlayerMMRType_1v1Competitive EDOTAPlayerMMRType = 5
|
|
EDOTAPlayerMMRType_k_EDOTAPlayerMMRType_GeneralSeasonalRanked EDOTAPlayerMMRType = 6
|
|
EDOTAPlayerMMRType_k_EDOTAPlayerMMRType_SoloSeasonalRanked EDOTAPlayerMMRType = 7
|
|
)
|
|
|
|
var EDOTAPlayerMMRType_name = map[int32]string{
|
|
0: "k_EDOTAPlayerMMRType_Invalid",
|
|
1: "k_EDOTAPlayerMMRType_GeneralHidden",
|
|
2: "k_EDOTAPlayerMMRType_SoloHidden",
|
|
3: "k_EDOTAPlayerMMRType_GeneralCompetitive",
|
|
4: "k_EDOTAPlayerMMRType_SoloCompetitive",
|
|
5: "k_EDOTAPlayerMMRType_1v1Competitive",
|
|
6: "k_EDOTAPlayerMMRType_GeneralSeasonalRanked",
|
|
7: "k_EDOTAPlayerMMRType_SoloSeasonalRanked",
|
|
}
|
|
var EDOTAPlayerMMRType_value = map[string]int32{
|
|
"k_EDOTAPlayerMMRType_Invalid": 0,
|
|
"k_EDOTAPlayerMMRType_GeneralHidden": 1,
|
|
"k_EDOTAPlayerMMRType_SoloHidden": 2,
|
|
"k_EDOTAPlayerMMRType_GeneralCompetitive": 3,
|
|
"k_EDOTAPlayerMMRType_SoloCompetitive": 4,
|
|
"k_EDOTAPlayerMMRType_1v1Competitive": 5,
|
|
"k_EDOTAPlayerMMRType_GeneralSeasonalRanked": 6,
|
|
"k_EDOTAPlayerMMRType_SoloSeasonalRanked": 7,
|
|
}
|
|
|
|
func (x EDOTAPlayerMMRType) Enum() *EDOTAPlayerMMRType {
|
|
p := new(EDOTAPlayerMMRType)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x EDOTAPlayerMMRType) String() string {
|
|
return proto.EnumName(EDOTAPlayerMMRType_name, int32(x))
|
|
}
|
|
func (x *EDOTAPlayerMMRType) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(EDOTAPlayerMMRType_value, data, "EDOTAPlayerMMRType")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = EDOTAPlayerMMRType(value)
|
|
return nil
|
|
}
|
|
func (EDOTAPlayerMMRType) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{21} }
|
|
|
|
type MatchType int32
|
|
|
|
const (
|
|
MatchType_MATCH_TYPE_CASUAL MatchType = 0
|
|
MatchType_MATCH_TYPE_COOP_BOTS MatchType = 1
|
|
MatchType_MATCH_TYPE_TEAM_RANKED MatchType = 2
|
|
MatchType_MATCH_TYPE_LEGACY_SOLO_QUEUE MatchType = 3
|
|
MatchType_MATCH_TYPE_COMPETITIVE MatchType = 4
|
|
MatchType_MATCH_TYPE_WEEKEND_TOURNEY MatchType = 5
|
|
MatchType_MATCH_TYPE_CASUAL_1V1 MatchType = 6
|
|
MatchType_MATCH_TYPE_EVENT MatchType = 7
|
|
MatchType_MATCH_TYPE_SEASONAL_RANKED MatchType = 8
|
|
)
|
|
|
|
var MatchType_name = map[int32]string{
|
|
0: "MATCH_TYPE_CASUAL",
|
|
1: "MATCH_TYPE_COOP_BOTS",
|
|
2: "MATCH_TYPE_TEAM_RANKED",
|
|
3: "MATCH_TYPE_LEGACY_SOLO_QUEUE",
|
|
4: "MATCH_TYPE_COMPETITIVE",
|
|
5: "MATCH_TYPE_WEEKEND_TOURNEY",
|
|
6: "MATCH_TYPE_CASUAL_1V1",
|
|
7: "MATCH_TYPE_EVENT",
|
|
8: "MATCH_TYPE_SEASONAL_RANKED",
|
|
}
|
|
var MatchType_value = map[string]int32{
|
|
"MATCH_TYPE_CASUAL": 0,
|
|
"MATCH_TYPE_COOP_BOTS": 1,
|
|
"MATCH_TYPE_TEAM_RANKED": 2,
|
|
"MATCH_TYPE_LEGACY_SOLO_QUEUE": 3,
|
|
"MATCH_TYPE_COMPETITIVE": 4,
|
|
"MATCH_TYPE_WEEKEND_TOURNEY": 5,
|
|
"MATCH_TYPE_CASUAL_1V1": 6,
|
|
"MATCH_TYPE_EVENT": 7,
|
|
"MATCH_TYPE_SEASONAL_RANKED": 8,
|
|
}
|
|
|
|
func (x MatchType) Enum() *MatchType {
|
|
p := new(MatchType)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x MatchType) String() string {
|
|
return proto.EnumName(MatchType_name, int32(x))
|
|
}
|
|
func (x *MatchType) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(MatchType_value, data, "MatchType")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = MatchType(value)
|
|
return nil
|
|
}
|
|
func (MatchType) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{22} }
|
|
|
|
type DOTABotDifficulty int32
|
|
|
|
const (
|
|
DOTABotDifficulty_BOT_DIFFICULTY_PASSIVE DOTABotDifficulty = 0
|
|
DOTABotDifficulty_BOT_DIFFICULTY_EASY DOTABotDifficulty = 1
|
|
DOTABotDifficulty_BOT_DIFFICULTY_MEDIUM DOTABotDifficulty = 2
|
|
DOTABotDifficulty_BOT_DIFFICULTY_HARD DOTABotDifficulty = 3
|
|
DOTABotDifficulty_BOT_DIFFICULTY_UNFAIR DOTABotDifficulty = 4
|
|
DOTABotDifficulty_BOT_DIFFICULTY_INVALID DOTABotDifficulty = 5
|
|
DOTABotDifficulty_BOT_DIFFICULTY_EXTRA1 DOTABotDifficulty = 6
|
|
DOTABotDifficulty_BOT_DIFFICULTY_EXTRA2 DOTABotDifficulty = 7
|
|
DOTABotDifficulty_BOT_DIFFICULTY_EXTRA3 DOTABotDifficulty = 8
|
|
)
|
|
|
|
var DOTABotDifficulty_name = map[int32]string{
|
|
0: "BOT_DIFFICULTY_PASSIVE",
|
|
1: "BOT_DIFFICULTY_EASY",
|
|
2: "BOT_DIFFICULTY_MEDIUM",
|
|
3: "BOT_DIFFICULTY_HARD",
|
|
4: "BOT_DIFFICULTY_UNFAIR",
|
|
5: "BOT_DIFFICULTY_INVALID",
|
|
6: "BOT_DIFFICULTY_EXTRA1",
|
|
7: "BOT_DIFFICULTY_EXTRA2",
|
|
8: "BOT_DIFFICULTY_EXTRA3",
|
|
}
|
|
var DOTABotDifficulty_value = map[string]int32{
|
|
"BOT_DIFFICULTY_PASSIVE": 0,
|
|
"BOT_DIFFICULTY_EASY": 1,
|
|
"BOT_DIFFICULTY_MEDIUM": 2,
|
|
"BOT_DIFFICULTY_HARD": 3,
|
|
"BOT_DIFFICULTY_UNFAIR": 4,
|
|
"BOT_DIFFICULTY_INVALID": 5,
|
|
"BOT_DIFFICULTY_EXTRA1": 6,
|
|
"BOT_DIFFICULTY_EXTRA2": 7,
|
|
"BOT_DIFFICULTY_EXTRA3": 8,
|
|
}
|
|
|
|
func (x DOTABotDifficulty) Enum() *DOTABotDifficulty {
|
|
p := new(DOTABotDifficulty)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x DOTABotDifficulty) String() string {
|
|
return proto.EnumName(DOTABotDifficulty_name, int32(x))
|
|
}
|
|
func (x *DOTABotDifficulty) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(DOTABotDifficulty_value, data, "DOTABotDifficulty")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = DOTABotDifficulty(value)
|
|
return nil
|
|
}
|
|
func (DOTABotDifficulty) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{23} }
|
|
|
|
type MatchLanguages int32
|
|
|
|
const (
|
|
MatchLanguages_MATCH_LANGUAGE_INVALID MatchLanguages = 0
|
|
MatchLanguages_MATCH_LANGUAGE_ENGLISH MatchLanguages = 1
|
|
MatchLanguages_MATCH_LANGUAGE_RUSSIAN MatchLanguages = 2
|
|
MatchLanguages_MATCH_LANGUAGE_CHINESE MatchLanguages = 3
|
|
MatchLanguages_MATCH_LANGUAGE_KOREAN MatchLanguages = 4
|
|
MatchLanguages_MATCH_LANGUAGE_SPANISH MatchLanguages = 5
|
|
MatchLanguages_MATCH_LANGUAGE_PORTUGUESE MatchLanguages = 6
|
|
MatchLanguages_MATCH_LANGUAGE_ENGLISH2 MatchLanguages = 7
|
|
)
|
|
|
|
var MatchLanguages_name = map[int32]string{
|
|
0: "MATCH_LANGUAGE_INVALID",
|
|
1: "MATCH_LANGUAGE_ENGLISH",
|
|
2: "MATCH_LANGUAGE_RUSSIAN",
|
|
3: "MATCH_LANGUAGE_CHINESE",
|
|
4: "MATCH_LANGUAGE_KOREAN",
|
|
5: "MATCH_LANGUAGE_SPANISH",
|
|
6: "MATCH_LANGUAGE_PORTUGUESE",
|
|
7: "MATCH_LANGUAGE_ENGLISH2",
|
|
}
|
|
var MatchLanguages_value = map[string]int32{
|
|
"MATCH_LANGUAGE_INVALID": 0,
|
|
"MATCH_LANGUAGE_ENGLISH": 1,
|
|
"MATCH_LANGUAGE_RUSSIAN": 2,
|
|
"MATCH_LANGUAGE_CHINESE": 3,
|
|
"MATCH_LANGUAGE_KOREAN": 4,
|
|
"MATCH_LANGUAGE_SPANISH": 5,
|
|
"MATCH_LANGUAGE_PORTUGUESE": 6,
|
|
"MATCH_LANGUAGE_ENGLISH2": 7,
|
|
}
|
|
|
|
func (x MatchLanguages) Enum() *MatchLanguages {
|
|
p := new(MatchLanguages)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x MatchLanguages) String() string {
|
|
return proto.EnumName(MatchLanguages_name, int32(x))
|
|
}
|
|
func (x *MatchLanguages) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(MatchLanguages_value, data, "MatchLanguages")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = MatchLanguages(value)
|
|
return nil
|
|
}
|
|
func (MatchLanguages) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{24} }
|
|
|
|
type ETourneyQueueDeadlineState int32
|
|
|
|
const (
|
|
ETourneyQueueDeadlineState_k_ETourneyQueueDeadlineState_Normal ETourneyQueueDeadlineState = 0
|
|
ETourneyQueueDeadlineState_k_ETourneyQueueDeadlineState_Missed ETourneyQueueDeadlineState = 1
|
|
ETourneyQueueDeadlineState_k_ETourneyQueueDeadlineState_ExpiredOK ETourneyQueueDeadlineState = 2
|
|
ETourneyQueueDeadlineState_k_ETourneyQueueDeadlineState_SeekingBye ETourneyQueueDeadlineState = 3
|
|
ETourneyQueueDeadlineState_k_ETourneyQueueDeadlineState_EligibleForRefund ETourneyQueueDeadlineState = 4
|
|
ETourneyQueueDeadlineState_k_ETourneyQueueDeadlineState_NA ETourneyQueueDeadlineState = -1
|
|
ETourneyQueueDeadlineState_k_ETourneyQueueDeadlineState_ExpiringSoon ETourneyQueueDeadlineState = 101
|
|
)
|
|
|
|
var ETourneyQueueDeadlineState_name = map[int32]string{
|
|
0: "k_ETourneyQueueDeadlineState_Normal",
|
|
1: "k_ETourneyQueueDeadlineState_Missed",
|
|
2: "k_ETourneyQueueDeadlineState_ExpiredOK",
|
|
3: "k_ETourneyQueueDeadlineState_SeekingBye",
|
|
4: "k_ETourneyQueueDeadlineState_EligibleForRefund",
|
|
-1: "k_ETourneyQueueDeadlineState_NA",
|
|
101: "k_ETourneyQueueDeadlineState_ExpiringSoon",
|
|
}
|
|
var ETourneyQueueDeadlineState_value = map[string]int32{
|
|
"k_ETourneyQueueDeadlineState_Normal": 0,
|
|
"k_ETourneyQueueDeadlineState_Missed": 1,
|
|
"k_ETourneyQueueDeadlineState_ExpiredOK": 2,
|
|
"k_ETourneyQueueDeadlineState_SeekingBye": 3,
|
|
"k_ETourneyQueueDeadlineState_EligibleForRefund": 4,
|
|
"k_ETourneyQueueDeadlineState_NA": -1,
|
|
"k_ETourneyQueueDeadlineState_ExpiringSoon": 101,
|
|
}
|
|
|
|
func (x ETourneyQueueDeadlineState) Enum() *ETourneyQueueDeadlineState {
|
|
p := new(ETourneyQueueDeadlineState)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x ETourneyQueueDeadlineState) String() string {
|
|
return proto.EnumName(ETourneyQueueDeadlineState_name, int32(x))
|
|
}
|
|
func (x *ETourneyQueueDeadlineState) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(ETourneyQueueDeadlineState_value, data, "ETourneyQueueDeadlineState")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = ETourneyQueueDeadlineState(value)
|
|
return nil
|
|
}
|
|
func (ETourneyQueueDeadlineState) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{25} }
|
|
|
|
type EMatchOutcome int32
|
|
|
|
const (
|
|
EMatchOutcome_k_EMatchOutcome_Unknown EMatchOutcome = 0
|
|
EMatchOutcome_k_EMatchOutcome_RadVictory EMatchOutcome = 2
|
|
EMatchOutcome_k_EMatchOutcome_DireVictory EMatchOutcome = 3
|
|
EMatchOutcome_k_EMatchOutcome_NotScored_PoorNetworkConditions EMatchOutcome = 64
|
|
EMatchOutcome_k_EMatchOutcome_NotScored_Leaver EMatchOutcome = 65
|
|
EMatchOutcome_k_EMatchOutcome_NotScored_ServerCrash EMatchOutcome = 66
|
|
EMatchOutcome_k_EMatchOutcome_NotScored_NeverStarted EMatchOutcome = 67
|
|
EMatchOutcome_k_EMatchOutcome_NotScored_Canceled EMatchOutcome = 68
|
|
)
|
|
|
|
var EMatchOutcome_name = map[int32]string{
|
|
0: "k_EMatchOutcome_Unknown",
|
|
2: "k_EMatchOutcome_RadVictory",
|
|
3: "k_EMatchOutcome_DireVictory",
|
|
64: "k_EMatchOutcome_NotScored_PoorNetworkConditions",
|
|
65: "k_EMatchOutcome_NotScored_Leaver",
|
|
66: "k_EMatchOutcome_NotScored_ServerCrash",
|
|
67: "k_EMatchOutcome_NotScored_NeverStarted",
|
|
68: "k_EMatchOutcome_NotScored_Canceled",
|
|
}
|
|
var EMatchOutcome_value = map[string]int32{
|
|
"k_EMatchOutcome_Unknown": 0,
|
|
"k_EMatchOutcome_RadVictory": 2,
|
|
"k_EMatchOutcome_DireVictory": 3,
|
|
"k_EMatchOutcome_NotScored_PoorNetworkConditions": 64,
|
|
"k_EMatchOutcome_NotScored_Leaver": 65,
|
|
"k_EMatchOutcome_NotScored_ServerCrash": 66,
|
|
"k_EMatchOutcome_NotScored_NeverStarted": 67,
|
|
"k_EMatchOutcome_NotScored_Canceled": 68,
|
|
}
|
|
|
|
func (x EMatchOutcome) Enum() *EMatchOutcome {
|
|
p := new(EMatchOutcome)
|
|
*p = x
|
|
return p
|
|
}
|
|
func (x EMatchOutcome) String() string {
|
|
return proto.EnumName(EMatchOutcome_name, int32(x))
|
|
}
|
|
func (x *EMatchOutcome) UnmarshalJSON(data []byte) error {
|
|
value, err := proto.UnmarshalJSONEnum(EMatchOutcome_value, data, "EMatchOutcome")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*x = EMatchOutcome(value)
|
|
return nil
|
|
}
|
|
func (EMatchOutcome) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{26} }
|
|
|
|
type CDOTAClientHardwareSpecs struct {
|
|
LogicalProcessors *uint32 `protobuf:"varint,1,opt,name=logical_processors" json:"logical_processors,omitempty"`
|
|
CpuCyclesPerSecond *uint64 `protobuf:"fixed64,2,opt,name=cpu_cycles_per_second" json:"cpu_cycles_per_second,omitempty"`
|
|
TotalPhysicalMemory *uint64 `protobuf:"fixed64,3,opt,name=total_physical_memory" json:"total_physical_memory,omitempty"`
|
|
Is_64BitOs *bool `protobuf:"varint,4,opt,name=is_64_bit_os" json:"is_64_bit_os,omitempty"`
|
|
UploadMeasurement *uint64 `protobuf:"varint,5,opt,name=upload_measurement" json:"upload_measurement,omitempty"`
|
|
PreferNotHost *bool `protobuf:"varint,6,opt,name=prefer_not_host" json:"prefer_not_host,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *CDOTAClientHardwareSpecs) Reset() { *m = CDOTAClientHardwareSpecs{} }
|
|
func (m *CDOTAClientHardwareSpecs) String() string { return proto.CompactTextString(m) }
|
|
func (*CDOTAClientHardwareSpecs) ProtoMessage() {}
|
|
func (*CDOTAClientHardwareSpecs) Descriptor() ([]byte, []int) { return fileDescriptor23, []int{0} }
|
|
|
|
func (m *CDOTAClientHardwareSpecs) GetLogicalProcessors() uint32 {
|
|
if m != nil && m.LogicalProcessors != nil {
|
|
return *m.LogicalProcessors
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *CDOTAClientHardwareSpecs) GetCpuCyclesPerSecond() uint64 {
|
|
if m != nil && m.CpuCyclesPerSecond != nil {
|
|
return *m.CpuCyclesPerSecond
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *CDOTAClientHardwareSpecs) GetTotalPhysicalMemory() uint64 {
|
|
if m != nil && m.TotalPhysicalMemory != nil {
|
|
return *m.TotalPhysicalMemory
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *CDOTAClientHardwareSpecs) GetIs_64BitOs() bool {
|
|
if m != nil && m.Is_64BitOs != nil {
|
|
return *m.Is_64BitOs
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *CDOTAClientHardwareSpecs) GetUploadMeasurement() uint64 {
|
|
if m != nil && m.UploadMeasurement != nil {
|
|
return *m.UploadMeasurement
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *CDOTAClientHardwareSpecs) GetPreferNotHost() bool {
|
|
if m != nil && m.PreferNotHost != nil {
|
|
return *m.PreferNotHost
|
|
}
|
|
return false
|
|
}
|
|
|
|
type CDOTASaveGame struct {
|
|
MatchId *uint64 `protobuf:"varint,5,opt,name=match_id" json:"match_id,omitempty"`
|
|
SaveTime *uint32 `protobuf:"varint,2,opt,name=save_time" json:"save_time,omitempty"`
|
|
Players []*CDOTASaveGame_Player `protobuf:"bytes,3,rep,name=players" json:"players,omitempty"`
|
|
SaveInstances []*CDOTASaveGame_SaveInstance `protobuf:"bytes,4,rep,name=save_instances" json:"save_instances,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *CDOTASaveGame) Reset() { *m = CDOTASaveGame{} }
|
|
func (m *CDOTASaveGame) String() string { return proto.CompactTextString(m) }
|
|
func (*CDOTASaveGame) ProtoMessage() {}
|
|
func (*CDOTASaveGame) Descriptor() ([]byte, []int) { return fileDescriptor23, []int{1} }
|
|
|
|
func (m *CDOTASaveGame) GetMatchId() uint64 {
|
|
if m != nil && m.MatchId != nil {
|
|
return *m.MatchId
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *CDOTASaveGame) GetSaveTime() uint32 {
|
|
if m != nil && m.SaveTime != nil {
|
|
return *m.SaveTime
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *CDOTASaveGame) GetPlayers() []*CDOTASaveGame_Player {
|
|
if m != nil {
|
|
return m.Players
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *CDOTASaveGame) GetSaveInstances() []*CDOTASaveGame_SaveInstance {
|
|
if m != nil {
|
|
return m.SaveInstances
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type CDOTASaveGame_Player struct {
|
|
Team *DOTA_GC_TEAM `protobuf:"varint,1,opt,name=team,enum=dota.DOTA_GC_TEAM,def=0" json:"team,omitempty"`
|
|
Name *string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"`
|
|
Hero *string `protobuf:"bytes,3,opt,name=hero" json:"hero,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *CDOTASaveGame_Player) Reset() { *m = CDOTASaveGame_Player{} }
|
|
func (m *CDOTASaveGame_Player) String() string { return proto.CompactTextString(m) }
|
|
func (*CDOTASaveGame_Player) ProtoMessage() {}
|
|
func (*CDOTASaveGame_Player) Descriptor() ([]byte, []int) { return fileDescriptor23, []int{1, 0} }
|
|
|
|
const Default_CDOTASaveGame_Player_Team DOTA_GC_TEAM = DOTA_GC_TEAM_DOTA_GC_TEAM_GOOD_GUYS
|
|
|
|
func (m *CDOTASaveGame_Player) GetTeam() DOTA_GC_TEAM {
|
|
if m != nil && m.Team != nil {
|
|
return *m.Team
|
|
}
|
|
return Default_CDOTASaveGame_Player_Team
|
|
}
|
|
|
|
func (m *CDOTASaveGame_Player) GetName() string {
|
|
if m != nil && m.Name != nil {
|
|
return *m.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *CDOTASaveGame_Player) GetHero() string {
|
|
if m != nil && m.Hero != nil {
|
|
return *m.Hero
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type CDOTASaveGame_SaveInstance struct {
|
|
GameTime *uint32 `protobuf:"varint,2,opt,name=game_time" json:"game_time,omitempty"`
|
|
Team1Score *uint32 `protobuf:"varint,3,opt,name=team1_score" json:"team1_score,omitempty"`
|
|
Team2Score *uint32 `protobuf:"varint,4,opt,name=team2_score" json:"team2_score,omitempty"`
|
|
PlayerPositions []*CDOTASaveGame_SaveInstance_PlayerPositions `protobuf:"bytes,5,rep,name=player_positions" json:"player_positions,omitempty"`
|
|
SaveId *uint32 `protobuf:"varint,6,opt,name=save_id" json:"save_id,omitempty"`
|
|
SaveTime *uint32 `protobuf:"varint,7,opt,name=save_time" json:"save_time,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *CDOTASaveGame_SaveInstance) Reset() { *m = CDOTASaveGame_SaveInstance{} }
|
|
func (m *CDOTASaveGame_SaveInstance) String() string { return proto.CompactTextString(m) }
|
|
func (*CDOTASaveGame_SaveInstance) ProtoMessage() {}
|
|
func (*CDOTASaveGame_SaveInstance) Descriptor() ([]byte, []int) { return fileDescriptor23, []int{1, 1} }
|
|
|
|
func (m *CDOTASaveGame_SaveInstance) GetGameTime() uint32 {
|
|
if m != nil && m.GameTime != nil {
|
|
return *m.GameTime
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *CDOTASaveGame_SaveInstance) GetTeam1Score() uint32 {
|
|
if m != nil && m.Team1Score != nil {
|
|
return *m.Team1Score
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *CDOTASaveGame_SaveInstance) GetTeam2Score() uint32 {
|
|
if m != nil && m.Team2Score != nil {
|
|
return *m.Team2Score
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *CDOTASaveGame_SaveInstance) GetPlayerPositions() []*CDOTASaveGame_SaveInstance_PlayerPositions {
|
|
if m != nil {
|
|
return m.PlayerPositions
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *CDOTASaveGame_SaveInstance) GetSaveId() uint32 {
|
|
if m != nil && m.SaveId != nil {
|
|
return *m.SaveId
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *CDOTASaveGame_SaveInstance) GetSaveTime() uint32 {
|
|
if m != nil && m.SaveTime != nil {
|
|
return *m.SaveTime
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type CDOTASaveGame_SaveInstance_PlayerPositions struct {
|
|
X *float32 `protobuf:"fixed32,1,opt,name=x" json:"x,omitempty"`
|
|
Y *float32 `protobuf:"fixed32,2,opt,name=y" json:"y,omitempty"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
}
|
|
|
|
func (m *CDOTASaveGame_SaveInstance_PlayerPositions) Reset() {
|
|
*m = CDOTASaveGame_SaveInstance_PlayerPositions{}
|
|
}
|
|
func (m *CDOTASaveGame_SaveInstance_PlayerPositions) String() string {
|
|
return proto.CompactTextString(m)
|
|
}
|
|
func (*CDOTASaveGame_SaveInstance_PlayerPositions) ProtoMessage() {}
|
|
func (*CDOTASaveGame_SaveInstance_PlayerPositions) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor23, []int{1, 1, 0}
|
|
}
|
|
|
|
func (m *CDOTASaveGame_SaveInstance_PlayerPositions) GetX() float32 {
|
|
if m != nil && m.X != nil {
|
|
return *m.X
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *CDOTASaveGame_SaveInstance_PlayerPositions) GetY() float32 {
|
|
if m != nil && m.Y != nil {
|
|
return *m.Y
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func init() {
|
|
proto.RegisterType((*CDOTAClientHardwareSpecs)(nil), "dota.CDOTAClientHardwareSpecs")
|
|
proto.RegisterType((*CDOTASaveGame)(nil), "dota.CDOTASaveGame")
|
|
proto.RegisterType((*CDOTASaveGame_Player)(nil), "dota.CDOTASaveGame.Player")
|
|
proto.RegisterType((*CDOTASaveGame_SaveInstance)(nil), "dota.CDOTASaveGame.SaveInstance")
|
|
proto.RegisterType((*CDOTASaveGame_SaveInstance_PlayerPositions)(nil), "dota.CDOTASaveGame.SaveInstance.PlayerPositions")
|
|
proto.RegisterEnum("dota.DOTA_GameMode", DOTA_GameMode_name, DOTA_GameMode_value)
|
|
proto.RegisterEnum("dota.DOTA_GameState", DOTA_GameState_name, DOTA_GameState_value)
|
|
proto.RegisterEnum("dota.DOTA_GC_TEAM", DOTA_GC_TEAM_name, DOTA_GC_TEAM_value)
|
|
proto.RegisterEnum("dota.EEvent", EEvent_name, EEvent_value)
|
|
proto.RegisterEnum("dota.DOTALeaverStatusT", DOTALeaverStatusT_name, DOTALeaverStatusT_value)
|
|
proto.RegisterEnum("dota.DOTAConnectionStateT", DOTAConnectionStateT_name, DOTAConnectionStateT_value)
|
|
proto.RegisterEnum("dota.Fantasy_Roles", Fantasy_Roles_name, Fantasy_Roles_value)
|
|
proto.RegisterEnum("dota.Fantasy_Team_Slots", Fantasy_Team_Slots_name, Fantasy_Team_Slots_value)
|
|
proto.RegisterEnum("dota.Fantasy_Selection_Mode", Fantasy_Selection_Mode_name, Fantasy_Selection_Mode_value)
|
|
proto.RegisterEnum("dota.DOTAChatChannelTypeT", DOTAChatChannelTypeT_name, DOTAChatChannelTypeT_value)
|
|
proto.RegisterEnum("dota.EProfileCardSlotType", EProfileCardSlotType_name, EProfileCardSlotType_value)
|
|
proto.RegisterEnum("dota.EMatchGroupServerStatus", EMatchGroupServerStatus_name, EMatchGroupServerStatus_value)
|
|
proto.RegisterEnum("dota.DOTA_CM_PICK", DOTA_CM_PICK_name, DOTA_CM_PICK_value)
|
|
proto.RegisterEnum("dota.DOTALowPriorityBanType", DOTALowPriorityBanType_name, DOTALowPriorityBanType_value)
|
|
proto.RegisterEnum("dota.DOTALobbyReadyState", DOTALobbyReadyState_name, DOTALobbyReadyState_value)
|
|
proto.RegisterEnum("dota.DOTAGameVersion", DOTAGameVersion_name, DOTAGameVersion_value)
|
|
proto.RegisterEnum("dota.DOTAJoinLobbyResult", DOTAJoinLobbyResult_name, DOTAJoinLobbyResult_value)
|
|
proto.RegisterEnum("dota.SelectionPriorityType", SelectionPriorityType_name, SelectionPriorityType_value)
|
|
proto.RegisterEnum("dota.DOTAMatchVote", DOTAMatchVote_name, DOTAMatchVote_value)
|
|
proto.RegisterEnum("dota.DOTA_LobbyMemberXPBonus", DOTA_LobbyMemberXPBonus_name, DOTA_LobbyMemberXPBonus_value)
|
|
proto.RegisterEnum("dota.DOTALobbyVisibility", DOTALobbyVisibility_name, DOTALobbyVisibility_value)
|
|
proto.RegisterEnum("dota.EDOTAPlayerMMRType", EDOTAPlayerMMRType_name, EDOTAPlayerMMRType_value)
|
|
proto.RegisterEnum("dota.MatchType", MatchType_name, MatchType_value)
|
|
proto.RegisterEnum("dota.DOTABotDifficulty", DOTABotDifficulty_name, DOTABotDifficulty_value)
|
|
proto.RegisterEnum("dota.MatchLanguages", MatchLanguages_name, MatchLanguages_value)
|
|
proto.RegisterEnum("dota.ETourneyQueueDeadlineState", ETourneyQueueDeadlineState_name, ETourneyQueueDeadlineState_value)
|
|
proto.RegisterEnum("dota.EMatchOutcome", EMatchOutcome_name, EMatchOutcome_value)
|
|
}
|
|
|
|
func init() { proto.RegisterFile("dota_shared_enums.proto", fileDescriptor23) }
|
|
|
|
var fileDescriptor23 = []byte{
|
|
// 3063 bytes of a gzipped FileDescriptorProto
|
|
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x84, 0x59, 0x4d, 0x8f, 0xe3, 0xc6,
|
|
0xd1, 0x5e, 0x69, 0x34, 0x5f, 0xbd, 0x3b, 0xbb, 0xb4, 0xf6, 0xc3, 0xe3, 0xf5, 0xd7, 0x7a, 0xfd,
|
|
0x2d, 0xbf, 0xde, 0xd7, 0xb3, 0xf6, 0x6b, 0xbc, 0xc8, 0x29, 0x14, 0xd5, 0x92, 0xb8, 0x43, 0x91,
|
|
0x32, 0x49, 0xcd, 0xac, 0x80, 0xc0, 0x04, 0x47, 0xe2, 0xec, 0x10, 0x2b, 0x89, 0x02, 0x49, 0xcd,
|
|
0x7a, 0x0e, 0x01, 0x82, 0x24, 0x40, 0x80, 0xe4, 0x9c, 0x6b, 0xce, 0xf9, 0x05, 0xbe, 0x05, 0xc9,
|
|
0x2d, 0xf7, 0x9c, 0x72, 0x09, 0x10, 0x24, 0xf9, 0x07, 0xf9, 0x01, 0xc9, 0xd3, 0xdd, 0x24, 0x45,
|
|
0x89, 0xd4, 0xd8, 0x80, 0xb1, 0x33, 0x55, 0x4f, 0x77, 0x57, 0x57, 0x57, 0x3d, 0x55, 0xc5, 0x21,
|
|
0xaf, 0x8f, 0x83, 0xd8, 0x75, 0xa2, 0x0b, 0x37, 0xf4, 0xc6, 0x8e, 0x37, 0x5b, 0x4c, 0xa3, 0x27,
|
|
0xf3, 0x30, 0x88, 0x83, 0x7a, 0x8d, 0x29, 0x1e, 0xff, 0xb1, 0x42, 0x0e, 0x95, 0x96, 0x61, 0xcb,
|
|
0xca, 0xc4, 0xf7, 0x66, 0x71, 0xd7, 0x0d, 0xc7, 0xaf, 0x00, 0xb5, 0xe6, 0xde, 0x28, 0xaa, 0x3f,
|
|
0x24, 0xf5, 0x49, 0xf0, 0xc2, 0x1f, 0xb9, 0x13, 0x07, 0x6b, 0x46, 0x5e, 0x14, 0x05, 0x61, 0x74,
|
|
0x58, 0x79, 0x54, 0xf9, 0xe4, 0xa0, 0xfe, 0x36, 0xb9, 0x3f, 0x9a, 0x2f, 0x9c, 0xd1, 0xd5, 0x68,
|
|
0xe2, 0x45, 0xce, 0xdc, 0x0b, 0x9d, 0xc8, 0x1b, 0x05, 0xb3, 0xf1, 0x61, 0x15, 0xea, 0x1d, 0xa6,
|
|
0x8e, 0xb1, 0x3f, 0x16, 0x5e, 0x5c, 0x45, 0x7c, 0x87, 0xa9, 0x37, 0x0d, 0xc2, 0xab, 0xc3, 0x2d,
|
|
0xae, 0xbe, 0x47, 0x6e, 0xf9, 0x91, 0xf3, 0xf5, 0x57, 0xce, 0x99, 0x1f, 0x3b, 0x41, 0x74, 0x58,
|
|
0x83, 0x74, 0x8f, 0x9d, 0xb7, 0x98, 0x4f, 0x02, 0x77, 0x0c, 0xb0, 0x1b, 0x2d, 0x42, 0x6f, 0x0a,
|
|
0x93, 0x0e, 0xb7, 0xa1, 0xab, 0xd5, 0x5f, 0x27, 0x77, 0xe6, 0xa1, 0x77, 0x8e, 0x73, 0x66, 0x41,
|
|
0xec, 0x5c, 0x04, 0x51, 0x7c, 0xb8, 0xc3, 0x16, 0x3d, 0xfe, 0xc7, 0x16, 0x39, 0xe0, 0x37, 0xb0,
|
|
0xdc, 0x4b, 0xaf, 0xe3, 0x4e, 0xbd, 0xba, 0x44, 0xf6, 0xa6, 0x6e, 0x3c, 0xba, 0x70, 0xfc, 0x71,
|
|
0xb2, 0xf8, 0x35, 0xb2, 0x1f, 0x41, 0xeb, 0xc4, 0xfe, 0xd4, 0xe3, 0x06, 0x1e, 0xd4, 0x3f, 0x23,
|
|
0xbb, 0xf3, 0x89, 0x7b, 0xe5, 0xe1, 0x42, 0x5b, 0x8f, 0xb6, 0x3e, 0xb9, 0xf9, 0xf4, 0xe1, 0x13,
|
|
0xe6, 0x90, 0x27, 0x2b, 0x5b, 0x3d, 0xe9, 0x73, 0x48, 0xfd, 0xff, 0xc9, 0x6d, 0xbe, 0xde, 0x9f,
|
|
0x45, 0xb1, 0x3b, 0x83, 0x23, 0x60, 0x30, 0x5b, 0xf3, 0xa8, 0x6c, 0x0d, 0xfb, 0x41, 0x4d, 0x80,
|
|
0x0f, 0xbf, 0x25, 0x3b, 0xd9, 0x1e, 0xb5, 0xd8, 0x73, 0xa7, 0xdc, 0x7d, 0xb7, 0x9f, 0xd6, 0xc5,
|
|
0x4a, 0xb6, 0xd0, 0xe9, 0x28, 0x8e, 0x4d, 0xe5, 0xde, 0x8f, 0x1e, 0xe4, 0x7f, 0x73, 0x3a, 0x86,
|
|
0xd1, 0x72, 0x3a, 0x83, 0xa1, 0x55, 0xbf, 0x45, 0x6a, 0x33, 0x37, 0x31, 0x7c, 0x9f, 0xfd, 0x76,
|
|
0xe1, 0x85, 0x01, 0x77, 0xe4, 0xfe, 0xc3, 0x7f, 0x55, 0xc8, 0xad, 0xfc, 0x81, 0xec, 0xaa, 0x2f,
|
|
0x00, 0xce, 0x5f, 0xf5, 0x2e, 0xb9, 0xc9, 0x4e, 0x3e, 0x72, 0xa2, 0x51, 0x10, 0x7a, 0x7c, 0x61,
|
|
0x26, 0x7c, 0x9a, 0x08, 0x6b, 0x5c, 0xf8, 0x8c, 0x48, 0xc2, 0x29, 0xce, 0x3c, 0x88, 0xfc, 0xd8,
|
|
0x0f, 0x66, 0x11, 0x3c, 0xc8, 0x6e, 0xfa, 0xc5, 0x0f, 0xdd, 0x34, 0x71, 0x55, 0x3f, 0x5d, 0x57,
|
|
0xbf, 0x43, 0x76, 0x85, 0xcf, 0xc6, 0xfc, 0xa1, 0x0e, 0x56, 0x1f, 0x61, 0x97, 0x89, 0x1e, 0x7e,
|
|
0x4c, 0xee, 0xac, 0x2f, 0xdb, 0x27, 0x95, 0xef, 0xb8, 0x8f, 0xaa, 0xec, 0xc7, 0x2b, 0x7e, 0x85,
|
|
0x6a, 0xe3, 0x4f, 0x35, 0x72, 0x20, 0xbc, 0x83, 0x73, 0x7b, 0xc1, 0xd8, 0xab, 0x3f, 0x20, 0x75,
|
|
0x21, 0x90, 0x7b, 0xb4, 0x67, 0xb4, 0xa8, 0xa3, 0x1b, 0x3a, 0x95, 0x6e, 0x20, 0xb2, 0xa4, 0x55,
|
|
0xb9, 0xdc, 0x97, 0x2a, 0x45, 0xa9, 0xd2, 0x93, 0xaa, 0x45, 0xa9, 0xd9, 0x92, 0xb6, 0x8a, 0x52,
|
|
0xab, 0x25, 0xd5, 0x4a, 0xf6, 0x35, 0xa5, 0x6d, 0x44, 0xe5, 0xdd, 0x55, 0xa9, 0xaa, 0xdb, 0xa6,
|
|
0x21, 0xed, 0x14, 0xe1, 0xdd, 0x53, 0x69, 0xb7, 0xfe, 0x16, 0x39, 0x5c, 0x3b, 0x90, 0x9e, 0x50,
|
|
0xd3, 0xe2, 0xe6, 0xec, 0x15, 0xaf, 0xf4, 0xbc, 0x27, 0x5b, 0xd2, 0x3e, 0xd2, 0xe2, 0xc1, 0xaa,
|
|
0xdc, 0x1e, 0xd8, 0x86, 0xa9, 0xca, 0x9a, 0x44, 0x8a, 0xe7, 0xf4, 0x0c, 0xe9, 0x66, 0x51, 0xaa,
|
|
0xf5, 0xa5, 0x5b, 0x45, 0x63, 0xfb, 0x86, 0xa1, 0x1d, 0x49, 0x07, 0x45, 0x78, 0xbb, 0x2b, 0xdd,
|
|
0xae, 0x1f, 0x92, 0x7b, 0x6b, 0x3e, 0x1b, 0x58, 0xb6, 0xd1, 0x93, 0xee, 0x94, 0x78, 0xb3, 0x25,
|
|
0x49, 0x45, 0x69, 0xb3, 0x25, 0xbd, 0x56, 0x7f, 0x97, 0xbc, 0xb9, 0xe6, 0xb7, 0xa6, 0xaa, 0xa9,
|
|
0xf6, 0xd0, 0x69, 0x99, 0x72, 0xdb, 0x96, 0xea, 0x45, 0xab, 0xe0, 0x12, 0xdd, 0x96, 0xee, 0x16,
|
|
0xdd, 0x21, 0x9b, 0xad, 0x9e, 0x74, 0xaf, 0x68, 0xd7, 0xd1, 0xc9, 0x51, 0x4f, 0x6d, 0x49, 0xf7,
|
|
0xeb, 0x6f, 0x92, 0xd7, 0xd7, 0x56, 0x68, 0x5a, 0x72, 0xce, 0x83, 0xc6, 0x1f, 0xb6, 0xc8, 0xed,
|
|
0x2c, 0x84, 0xac, 0xd8, 0x8d, 0x3d, 0x90, 0xd4, 0x1b, 0x19, 0xde, 0x1c, 0x68, 0xd4, 0x72, 0x2c,
|
|
0x5b, 0xb6, 0xd9, 0x23, 0xaa, 0x36, 0x42, 0xe9, 0x88, 0x7c, 0x5e, 0xaa, 0x3e, 0x95, 0x55, 0xdb,
|
|
0x69, 0x1b, 0xa6, 0xd3, 0xd7, 0xe4, 0x21, 0x9e, 0xcf, 0xb1, 0x0d, 0x47, 0x33, 0xe4, 0x16, 0xe2,
|
|
0xec, 0x63, 0xf2, 0x7e, 0xe9, 0x92, 0x2e, 0x35, 0x0d, 0xc7, 0xa2, 0x1a, 0x55, 0x6c, 0xd5, 0xd0,
|
|
0x11, 0x7a, 0x1f, 0x91, 0xc7, 0xa5, 0x40, 0xcb, 0x36, 0xf1, 0x4f, 0x67, 0xe8, 0xd8, 0x6a, 0x8f,
|
|
0x22, 0x18, 0xdf, 0x23, 0x6f, 0x97, 0xe2, 0xfa, 0x26, 0xe5, 0x32, 0x44, 0xe6, 0xa7, 0xe4, 0xc3,
|
|
0x52, 0x08, 0xfb, 0x1d, 0x57, 0x01, 0xd4, 0xe8, 0x98, 0xd4, 0xb2, 0x10, 0xae, 0x8f, 0xc9, 0x3b,
|
|
0xe5, 0xbb, 0x19, 0x96, 0x2d, 0xb6, 0xdb, 0xa9, 0xbf, 0x4f, 0xde, 0x2d, 0xc5, 0xb4, 0x54, 0x4b,
|
|
0x31, 0x74, 0x1d, 0x37, 0x40, 0x20, 0x6f, 0x32, 0x9f, 0x33, 0x97, 0xd5, 0x35, 0x4e, 0x15, 0xd9,
|
|
0xa2, 0x08, 0xe9, 0x06, 0xf9, 0xa8, 0x14, 0x27, 0x42, 0x49, 0x98, 0x68, 0x51, 0x7b, 0xd0, 0x47,
|
|
0x98, 0x6f, 0x7a, 0x0d, 0x4d, 0xb6, 0x6c, 0x89, 0x34, 0xbe, 0x07, 0xd3, 0xe5, 0x09, 0x72, 0x99,
|
|
0x16, 0xeb, 0x84, 0x89, 0xa7, 0x7b, 0x83, 0xdc, 0x5f, 0xd1, 0x35, 0xe5, 0x44, 0x55, 0x59, 0xe6,
|
|
0x60, 0xaa, 0x32, 0xf1, 0x74, 0x30, 0xd7, 0xa6, 0x26, 0xde, 0x65, 0x7d, 0x53, 0xab, 0x8f, 0x0b,
|
|
0xcb, 0x48, 0x37, 0xbc, 0xc5, 0xfa, 0x4a, 0xf1, 0xfc, 0x3c, 0x8b, 0xa4, 0xda, 0x32, 0x8e, 0x13,
|
|
0xad, 0x6e, 0xb0, 0x7f, 0xa4, 0xed, 0xc6, 0xf7, 0x5b, 0x64, 0x87, 0xd2, 0x4b, 0x94, 0x32, 0x50,
|
|
0xe0, 0x01, 0x8f, 0x6e, 0x47, 0x6d, 0xa5, 0x7c, 0x75, 0x9f, 0xbc, 0x96, 0x89, 0x5a, 0xaa, 0x49,
|
|
0x6d, 0xb5, 0x45, 0x85, 0x95, 0x99, 0xd8, 0xea, 0x9b, 0xaa, 0xde, 0x71, 0xda, 0xd4, 0xb2, 0xd5,
|
|
0x13, 0x64, 0x7d, 0x95, 0x05, 0x7a, 0xa6, 0x6d, 0x9b, 0x06, 0x93, 0x0f, 0x2c, 0xe7, 0xe9, 0x17,
|
|
0x47, 0x5f, 0x0a, 0x33, 0x33, 0xa5, 0x62, 0xf4, 0xfa, 0x54, 0x6f, 0xa9, 0x83, 0x1e, 0xd3, 0x7e,
|
|
0x05, 0x33, 0x71, 0xc1, 0xa5, 0x09, 0xf4, 0xb9, 0x81, 0xf8, 0x50, 0xe0, 0x1e, 0xbd, 0x83, 0xf0,
|
|
0xc8, 0xeb, 0xfa, 0xa7, 0x26, 0x0c, 0x92, 0x15, 0xb6, 0xee, 0xff, 0x10, 0x16, 0xf9, 0x23, 0x75,
|
|
0x7a, 0xea, 0x34, 0x35, 0xc3, 0xe8, 0x09, 0xe5, 0x2e, 0x4b, 0xf2, 0x4c, 0x09, 0x06, 0xa4, 0xa6,
|
|
0x2e, 0xb3, 0x38, 0x97, 0x35, 0x01, 0xd8, 0x5b, 0xb1, 0xa9, 0xcd, 0xb2, 0xb2, 0x27, 0x3f, 0x43,
|
|
0x02, 0x71, 0xed, 0x3e, 0xcb, 0xf4, 0x4c, 0x6b, 0x98, 0xb2, 0xa2, 0x21, 0x22, 0x65, 0x90, 0xdb,
|
|
0x07, 0xe4, 0xd1, 0x86, 0x33, 0x59, 0xfc, 0x37, 0x29, 0x0b, 0x8c, 0x9b, 0x2b, 0xab, 0x33, 0x67,
|
|
0x80, 0xee, 0xde, 0x21, 0x0f, 0x33, 0xf9, 0x29, 0xb7, 0x6a, 0x79, 0xea, 0xd7, 0x60, 0xbd, 0x6b,
|
|
0x8d, 0xfe, 0x5a, 0xba, 0xdd, 0xf8, 0x7d, 0x55, 0x30, 0x90, 0xe6, 0xa1, 0x6c, 0x85, 0x8c, 0x32,
|
|
0x16, 0x91, 0x13, 0x67, 0x3c, 0xa7, 0x51, 0x19, 0xe4, 0x9d, 0xbe, 0x63, 0x1a, 0x1c, 0x89, 0x74,
|
|
0x99, 0x2d, 0x94, 0xf1, 0xc2, 0x87, 0xe4, 0xbd, 0x4d, 0x5a, 0xb0, 0x07, 0xa3, 0x0f, 0x3c, 0x40,
|
|
0x35, 0x0b, 0xdb, 0x04, 0x26, 0xe3, 0x5d, 0x5a, 0xd8, 0x9e, 0x55, 0xa5, 0xbb, 0xe4, 0xce, 0x8a,
|
|
0xaa, 0x7d, 0x8c, 0xc7, 0x4c, 0xc9, 0x35, 0x35, 0x85, 0x55, 0x13, 0x67, 0x79, 0xee, 0x76, 0xfd,
|
|
0x13, 0xf2, 0xc1, 0x35, 0x80, 0xe5, 0xd1, 0x3b, 0x19, 0x35, 0x24, 0xc8, 0xb6, 0xac, 0x6a, 0x1c,
|
|
0x80, 0x12, 0x25, 0xb7, 0x86, 0x0e, 0x32, 0x74, 0x37, 0x63, 0xde, 0xf4, 0x16, 0x54, 0xd1, 0x54,
|
|
0x66, 0xdd, 0x5e, 0xe3, 0x77, 0x55, 0x61, 0xb9, 0x12, 0xcc, 0x66, 0xde, 0x88, 0x55, 0x72, 0xce,
|
|
0xb0, 0xf0, 0x56, 0x4a, 0x60, 0xc9, 0xa1, 0x70, 0x70, 0x92, 0xd6, 0x03, 0xfd, 0x58, 0x37, 0x4e,
|
|
0x75, 0xb8, 0xee, 0x33, 0xf2, 0x71, 0x39, 0x04, 0x29, 0xe4, 0x0c, 0xa9, 0xed, 0xe4, 0x3d, 0x99,
|
|
0xd2, 0x53, 0x01, 0xbc, 0x04, 0x2d, 0xd9, 0xb5, 0x00, 0x5a, 0x79, 0x96, 0xad, 0xcd, 0x9b, 0x2d,
|
|
0x3d, 0x5f, 0xdb, 0x7c, 0x03, 0xc6, 0xf9, 0x2a, 0x4f, 0x9c, 0x47, 0xe4, 0xad, 0x72, 0x88, 0x70,
|
|
0xa3, 0xb4, 0xd3, 0xf8, 0x09, 0x39, 0x68, 0xbb, 0xb3, 0xd8, 0x8d, 0xae, 0x1c, 0x33, 0x40, 0xc7,
|
|
0xcc, 0x72, 0xad, 0x2d, 0xeb, 0x68, 0xa6, 0x86, 0x8e, 0x69, 0x68, 0xcc, 0x1d, 0x2d, 0xda, 0xe6,
|
|
0xde, 0xe4, 0x9c, 0xb0, 0xa2, 0x53, 0x0c, 0x93, 0x71, 0x02, 0xdc, 0xbf, 0x22, 0xb6, 0x06, 0xfd,
|
|
0xbe, 0x61, 0xda, 0x52, 0xb5, 0xf1, 0xeb, 0x0a, 0xa9, 0xa7, 0xdb, 0xdb, 0xe8, 0xea, 0x1c, 0x6b,
|
|
0x12, 0xc4, 0x51, 0x7e, 0x1f, 0x4b, 0x83, 0x2f, 0x97, 0x94, 0xb3, 0x22, 0x2e, 0x6e, 0xcf, 0xc5,
|
|
0xd9, 0xf6, 0x2c, 0xe2, 0x57, 0x34, 0xb2, 0x3e, 0x84, 0xf3, 0x90, 0x77, 0x2b, 0xd2, 0x26, 0xd5,
|
|
0x95, 0xae, 0x54, 0x6b, 0xfc, 0xad, 0x8a, 0xab, 0x25, 0xc6, 0x58, 0xde, 0x44, 0x84, 0x83, 0xc3,
|
|
0x9b, 0x36, 0x50, 0x7c, 0xb6, 0x24, 0x2d, 0x86, 0xc8, 0x3d, 0x90, 0x9a, 0xda, 0x12, 0x39, 0x54,
|
|
0x54, 0x6b, 0x86, 0x72, 0xcc, 0x5f, 0xbe, 0x74, 0xb1, 0xd5, 0x1d, 0xb4, 0xdb, 0x1a, 0x85, 0x91,
|
|
0xc8, 0x85, 0xa2, 0xba, 0x6d, 0x52, 0x70, 0x89, 0xaa, 0x1c, 0xc3, 0x5e, 0x30, 0x58, 0x11, 0x00,
|
|
0x72, 0xe4, 0x8f, 0x8c, 0x17, 0x2c, 0x2a, 0x59, 0x91, 0xb5, 0xc0, 0x32, 0xa8, 0xd8, 0xdb, 0xe5,
|
|
0xfb, 0x33, 0x84, 0x68, 0x30, 0x76, 0x18, 0xdf, 0x14, 0x01, 0x5c, 0xc9, 0x82, 0x64, 0x97, 0xb1,
|
|
0x59, 0x51, 0x6f, 0xd2, 0xce, 0x40, 0x93, 0xcd, 0xf4, 0x98, 0xbd, 0x72, 0x43, 0x14, 0xb4, 0x3e,
|
|
0x20, 0x69, 0x0b, 0xa6, 0xee, 0x37, 0x7e, 0xbe, 0x9d, 0xe4, 0xda, 0x85, 0x1b, 0xe3, 0x7f, 0x24,
|
|
0xdc, 0xc4, 0xbe, 0x9a, 0xb3, 0x5c, 0x4b, 0x38, 0x28, 0x2f, 0x34, 0xbd, 0x17, 0xf0, 0xbe, 0x3b,
|
|
0x81, 0x77, 0x93, 0xd2, 0x96, 0xd7, 0x2a, 0x8b, 0x28, 0x0e, 0xa6, 0xf0, 0xed, 0x1b, 0xd9, 0x96,
|
|
0x99, 0xae, 0xef, 0x86, 0xf1, 0xd5, 0x92, 0x93, 0xf2, 0x2a, 0x2d, 0x38, 0x3b, 0xbb, 0x82, 0x47,
|
|
0x13, 0x3e, 0xc8, 0xab, 0x58, 0xf4, 0xc1, 0x9d, 0x25, 0x8b, 0x3a, 0x0b, 0x7f, 0x32, 0x86, 0x1f,
|
|
0x93, 0x26, 0x2d, 0xaf, 0x4a, 0xa2, 0x45, 0x54, 0x99, 0x75, 0xe5, 0xe9, 0x85, 0x1f, 0x61, 0xbc,
|
|
0x84, 0x03, 0x4b, 0x94, 0xe0, 0x9b, 0x08, 0xe9, 0x04, 0xbf, 0x25, 0xe5, 0x77, 0xc5, 0x16, 0xf7,
|
|
0x0c, 0xc5, 0xa5, 0x64, 0x95, 0x3a, 0xbb, 0x74, 0x27, 0xfe, 0x18, 0x15, 0xa6, 0x44, 0xc9, 0xda,
|
|
0x43, 0x79, 0x32, 0x41, 0x61, 0xc1, 0x83, 0x6e, 0x50, 0xfa, 0x5e, 0x84, 0x02, 0x93, 0x10, 0xc3,
|
|
0xba, 0x9e, 0xcd, 0xce, 0x20, 0xbf, 0x20, 0x44, 0x8d, 0x49, 0x88, 0x61, 0x1d, 0xa2, 0x04, 0xee,
|
|
0xe8, 0xc2, 0x9f, 0xbd, 0x58, 0x76, 0xd9, 0x2b, 0x97, 0x72, 0xcf, 0x3d, 0x74, 0xd9, 0x25, 0xc7,
|
|
0x8b, 0xf7, 0x62, 0x3b, 0xa0, 0xdf, 0x2e, 0xb1, 0xbd, 0x1f, 0xfa, 0x97, 0xa0, 0x5d, 0xb4, 0xdd,
|
|
0x25, 0xa1, 0x80, 0x19, 0x2b, 0xe6, 0x4b, 0xeb, 0x69, 0xab, 0x95, 0xd7, 0x36, 0xdd, 0x38, 0x9e,
|
|
0x78, 0xca, 0x62, 0x8e, 0xce, 0xbb, 0xe4, 0x62, 0x5d, 0xcd, 0x3e, 0x59, 0x5e, 0xec, 0x5e, 0xe3,
|
|
0x9f, 0x15, 0x72, 0x8f, 0xf6, 0xc3, 0xe0, 0xdc, 0xc7, 0x22, 0x37, 0x1c, 0x33, 0xc2, 0x61, 0x40,
|
|
0x76, 0xe3, 0x97, 0x4e, 0x99, 0xc6, 0xa1, 0xd3, 0x39, 0x02, 0xea, 0x06, 0x4b, 0xa4, 0x0d, 0x08,
|
|
0x56, 0x33, 0x10, 0x8c, 0x38, 0x7e, 0x03, 0xc0, 0x0e, 0x83, 0xf9, 0xc5, 0x95, 0x48, 0xf6, 0x0d,
|
|
0x10, 0x35, 0xf6, 0xa6, 0x08, 0xcd, 0xcd, 0x80, 0x2e, 0x86, 0x67, 0x44, 0x28, 0xa8, 0x7f, 0xa3,
|
|
0x9d, 0x41, 0xec, 0x8f, 0x82, 0x19, 0x5a, 0xb7, 0xdf, 0x56, 0xd0, 0xf5, 0xf4, 0xd8, 0xb7, 0x84,
|
|
0x4e, 0x18, 0x2c, 0xe6, 0x96, 0x17, 0x66, 0x8d, 0x40, 0x72, 0xd1, 0x72, 0xa5, 0x63, 0x1c, 0x8b,
|
|
0xf9, 0x61, 0x33, 0x42, 0xf3, 0xa7, 0x7e, 0xec, 0x8d, 0xe5, 0x4b, 0xd7, 0x9f, 0xb8, 0x67, 0xfe,
|
|
0xc4, 0x87, 0x6f, 0x78, 0x9f, 0x70, 0xcd, 0xa6, 0xe7, 0xe7, 0x13, 0x7f, 0xe6, 0x81, 0xef, 0x8d,
|
|
0xa4, 0x15, 0x56, 0x7a, 0x9c, 0xdc, 0xea, 0xf5, 0x64, 0xb4, 0xc1, 0xef, 0x26, 0x2b, 0x5c, 0x3d,
|
|
0xc1, 0xf2, 0xa9, 0x6c, 0xd9, 0x19, 0x2f, 0x27, 0x61, 0x25, 0xd7, 0x14, 0x57, 0x1b, 0xbf, 0xa9,
|
|
0x08, 0x72, 0xd0, 0x82, 0x57, 0x88, 0xa1, 0x20, 0x84, 0x35, 0x4d, 0x77, 0xc6, 0x1f, 0x34, 0x2d,
|
|
0x7f, 0x9a, 0x71, 0x0a, 0xba, 0x53, 0x31, 0x78, 0x62, 0x78, 0x43, 0x79, 0x4c, 0x6b, 0x24, 0x8e,
|
|
0xda, 0x08, 0x31, 0x29, 0xab, 0x20, 0xec, 0xd8, 0xb4, 0xc6, 0x17, 0x20, 0x16, 0x45, 0xd1, 0x6c,
|
|
0xc9, 0xe6, 0x30, 0xdb, 0xaf, 0xda, 0xf8, 0xa9, 0xc8, 0x65, 0x4e, 0x33, 0xa6, 0xe7, 0x8e, 0xaf,
|
|
0xc4, 0xb8, 0x96, 0xb4, 0x28, 0x6b, 0x62, 0x5e, 0x39, 0x15, 0x70, 0x28, 0x2f, 0x9d, 0x49, 0xc2,
|
|
0xad, 0x63, 0x64, 0x45, 0xa1, 0x7d, 0xd1, 0x40, 0x6c, 0x40, 0x64, 0xcd, 0x4c, 0xb5, 0xd1, 0x12,
|
|
0xad, 0x16, 0xcb, 0x95, 0x13, 0x2f, 0x8c, 0xc0, 0x9f, 0x2c, 0x4b, 0xf9, 0xac, 0xc2, 0xa6, 0x75,
|
|
0x4e, 0xc8, 0x03, 0xd3, 0x64, 0x53, 0xea, 0x0d, 0xc6, 0x3b, 0x2b, 0x1a, 0xd4, 0xfd, 0x26, 0xea,
|
|
0x51, 0xa5, 0xf1, 0x97, 0x2d, 0x71, 0x8b, 0x67, 0x81, 0x3f, 0x4b, 0x0e, 0x8b, 0x16, 0x93, 0x8c,
|
|
0xa4, 0x9d, 0x67, 0x86, 0xca, 0x1c, 0x64, 0x0d, 0x34, 0x56, 0x6a, 0x61, 0x9f, 0xc5, 0x06, 0x17,
|
|
0x14, 0x89, 0x82, 0x56, 0xd6, 0x44, 0x0f, 0x06, 0x09, 0x9f, 0xd1, 0x2a, 0x59, 0xb3, 0x96, 0x47,
|
|
0x25, 0x65, 0x14, 0x1e, 0x6e, 0x36, 0x87, 0x48, 0x91, 0x74, 0x14, 0x5d, 0xc5, 0xa0, 0xd6, 0x9b,
|
|
0x28, 0x2a, 0xe8, 0xaf, 0x2d, 0xeb, 0xd4, 0xe0, 0xdf, 0x3b, 0xca, 0x36, 0x93, 0xb9, 0x3d, 0x70,
|
|
0x8a, 0xae, 0xf2, 0xf2, 0x58, 0x86, 0xe9, 0x50, 0x9d, 0x9a, 0xaa, 0xe2, 0x50, 0xd3, 0x34, 0xd8,
|
|
0xb7, 0x90, 0xb4, 0xe9, 0x2a, 0x3f, 0x30, 0xf1, 0x4f, 0xae, 0xd3, 0x5c, 0xc5, 0x25, 0x23, 0x95,
|
|
0x6c, 0xda, 0x43, 0x50, 0x7d, 0xda, 0x98, 0xe5, 0x31, 0xba, 0x21, 0xee, 0x86, 0xd1, 0x1b, 0x4f,
|
|
0x0e, 0xca, 0x4f, 0xbb, 0xdf, 0x3c, 0x28, 0x41, 0x0c, 0x34, 0x0d, 0xd4, 0xff, 0x94, 0x3c, 0x29,
|
|
0x00, 0xf2, 0x93, 0x67, 0xd1, 0x3a, 0x52, 0xfa, 0x3c, 0x6c, 0x16, 0x37, 0x06, 0x98, 0x35, 0x1a,
|
|
0xdf, 0x92, 0xfb, 0x59, 0x4b, 0x93, 0x26, 0x0a, 0xcf, 0x92, 0x03, 0xb2, 0x9f, 0xef, 0xe0, 0x6e,
|
|
0x92, 0x5d, 0x13, 0xcd, 0x21, 0x0a, 0x39, 0x5e, 0x6b, 0x8f, 0xd4, 0xd8, 0x64, 0x87, 0x37, 0xb9,
|
|
0x4d, 0x48, 0x5b, 0x35, 0x31, 0x6b, 0x27, 0x2d, 0xc9, 0x1d, 0x72, 0x53, 0xc4, 0xbf, 0x10, 0xd4,
|
|
0x1a, 0x67, 0xe2, 0x33, 0x17, 0x27, 0x80, 0x93, 0x00, 0x31, 0x9f, 0x14, 0xd2, 0x4c, 0x90, 0xeb,
|
|
0x96, 0x92, 0x7a, 0xbe, 0x54, 0x61, 0x8a, 0x57, 0x31, 0xfc, 0xb0, 0x00, 0x29, 0xe8, 0x74, 0xda,
|
|
0x91, 0xb9, 0xae, 0xda, 0xf8, 0x45, 0x35, 0xf9, 0x4c, 0xc2, 0xa3, 0xb2, 0xe7, 0x4d, 0xcf, 0xbc,
|
|
0xf0, 0x79, 0xbf, 0x19, 0xcc, 0x40, 0x6a, 0xa9, 0xdf, 0x8b, 0x2a, 0xc4, 0x42, 0x5b, 0x86, 0x33,
|
|
0x70, 0x70, 0x3a, 0xd4, 0x97, 0x80, 0x9a, 0xb2, 0x6d, 0xa3, 0x33, 0x6d, 0x1a, 0x06, 0x9f, 0xa7,
|
|
0x97, 0x1f, 0x44, 0x4a, 0xb0, 0x56, 0x17, 0x39, 0x0b, 0xa8, 0x8e, 0x69, 0xad, 0xba, 0xe4, 0x90,
|
|
0x22, 0x50, 0x04, 0xc5, 0xd6, 0x75, 0x7b, 0xe1, 0x11, 0xcd, 0x81, 0x6a, 0xf7, 0x58, 0x4e, 0x2e,
|
|
0xa3, 0xb5, 0x6c, 0x2f, 0x45, 0xcc, 0xba, 0x8d, 0xef, 0x72, 0x1c, 0x73, 0xe2, 0x47, 0xbe, 0xa0,
|
|
0xe0, 0xb4, 0xe8, 0xae, 0x89, 0x9d, 0xfe, 0xe2, 0x6c, 0xe2, 0x8f, 0x44, 0xf1, 0x2a, 0xd3, 0xb7,
|
|
0x43, 0xdf, 0x9b, 0x8d, 0xa3, 0x35, 0x7a, 0xc9, 0x01, 0x06, 0xb3, 0x89, 0x1f, 0x81, 0xef, 0xe1,
|
|
0xff, 0xbf, 0x63, 0xac, 0xa4, 0x0c, 0x23, 0x3e, 0x7d, 0xf6, 0x7a, 0x66, 0xae, 0x70, 0x16, 0xe4,
|
|
0x59, 0xb3, 0x72, 0x83, 0x25, 0x58, 0x29, 0xa2, 0xe3, 0xcd, 0xbc, 0xd0, 0x9d, 0x74, 0xfd, 0xf1,
|
|
0xd8, 0x9b, 0x89, 0x11, 0xa9, 0x14, 0x67, 0x05, 0x93, 0x20, 0x01, 0x55, 0x19, 0x21, 0x5f, 0xb7,
|
|
0x99, 0x12, 0x4c, 0xe7, 0x5e, 0xec, 0xc7, 0xfe, 0xa5, 0x07, 0xcf, 0x63, 0x8c, 0xdc, 0xb8, 0x63,
|
|
0x1e, 0x59, 0x63, 0x6f, 0x54, 0x8a, 0x3c, 0xba, 0x3c, 0xca, 0x03, 0xb7, 0xeb, 0x4f, 0x48, 0xe3,
|
|
0xba, 0xf3, 0x2d, 0xcf, 0x8d, 0x58, 0xdf, 0x6a, 0xba, 0xb3, 0x97, 0xf0, 0xda, 0xce, 0x46, 0x7b,
|
|
0x99, 0x09, 0x6b, 0xe0, 0xdd, 0xc6, 0xaf, 0xaa, 0x64, 0x9f, 0xc7, 0x3e, 0xf7, 0x2c, 0x2a, 0x61,
|
|
0x4f, 0xb6, 0x95, 0xae, 0x63, 0x0f, 0xfb, 0x18, 0xa6, 0x64, 0x6b, 0x20, 0x6b, 0x70, 0x27, 0x38,
|
|
0x3d, 0x2f, 0x36, 0x8c, 0x3e, 0x82, 0x91, 0x17, 0x2b, 0x64, 0x4f, 0x4e, 0xc3, 0x89, 0x09, 0x65,
|
|
0xf5, 0x98, 0x8f, 0x96, 0x78, 0xa6, 0x9c, 0x4e, 0x43, 0x5a, 0x29, 0xe8, 0xd4, 0x0d, 0xcd, 0x70,
|
|
0xbe, 0x19, 0xd0, 0x01, 0xfb, 0x64, 0xb7, 0xba, 0x9a, 0x7f, 0x81, 0xb1, 0x45, 0x5e, 0xd6, 0x58,
|
|
0x78, 0xe5, 0x74, 0xa7, 0x94, 0x1e, 0x63, 0x00, 0xc1, 0x94, 0x3d, 0x30, 0x75, 0x3a, 0x84, 0x57,
|
|
0x90, 0xee, 0x05, 0x53, 0xd9, 0xf7, 0x4d, 0xf1, 0x45, 0x39, 0xa7, 0x12, 0x1f, 0x49, 0x77, 0xd7,
|
|
0x36, 0x14, 0x53, 0x04, 0x96, 0x24, 0xe6, 0xee, 0x35, 0x7e, 0x59, 0x15, 0x6d, 0x40, 0x33, 0x88,
|
|
0x5b, 0xfe, 0xf9, 0xb9, 0x3f, 0x42, 0x09, 0xba, 0x62, 0x26, 0xe2, 0xaa, 0x98, 0x86, 0xdb, 0x6d,
|
|
0x55, 0x41, 0x52, 0x0f, 0x79, 0x3d, 0x60, 0x26, 0xf2, 0x82, 0xb6, 0xa6, 0xc3, 0xa6, 0x43, 0x31,
|
|
0x23, 0xac, 0x29, 0x7a, 0x94, 0x7d, 0x59, 0x82, 0x53, 0x8a, 0x6b, 0x90, 0xdb, 0xac, 0xb6, 0x14,
|
|
0xd7, 0x0c, 0x74, 0xcc, 0xc4, 0xa6, 0xf8, 0x10, 0xb5, 0xa6, 0x4a, 0xa9, 0x6d, 0xbb, 0x64, 0x19,
|
|
0x7d, 0x6e, 0x9b, 0x32, 0x73, 0xc3, 0x06, 0xd5, 0x53, 0xf8, 0x62, 0x83, 0xea, 0x4b, 0xb8, 0xe1,
|
|
0xdf, 0x15, 0x72, 0x9b, 0x07, 0x84, 0xe6, 0xce, 0x5e, 0x2c, 0xdc, 0x17, 0x62, 0x00, 0x17, 0x9e,
|
|
0xd3, 0x40, 0x08, 0x03, 0xb9, 0x43, 0x57, 0xa9, 0x75, 0x4d, 0x47, 0xf5, 0x8e, 0xa6, 0x5a, 0xdd,
|
|
0x7c, 0x70, 0x64, 0x3a, 0x73, 0x00, 0xdf, 0xc9, 0xba, 0xf8, 0x7a, 0xb8, 0xa6, 0x53, 0xba, 0xa8,
|
|
0x08, 0x16, 0x15, 0xae, 0x58, 0xd3, 0x1d, 0x63, 0xee, 0xc6, 0xb2, 0x5a, 0xc9, 0x32, 0xab, 0x2f,
|
|
0xeb, 0xec, 0xb8, 0x6d, 0xd6, 0xaa, 0xaf, 0xe9, 0x58, 0x4b, 0x35, 0xe8, 0x0c, 0xd8, 0xae, 0x7c,
|
|
0x60, 0x2a, 0xb7, 0x14, 0x0e, 0x69, 0xfc, 0xb5, 0x4a, 0x1e, 0x52, 0x3b, 0x58, 0x84, 0x33, 0xef,
|
|
0xea, 0x9b, 0x85, 0xb7, 0xf0, 0x5a, 0xe8, 0x77, 0x58, 0x0b, 0x29, 0xfa, 0x29, 0x91, 0xab, 0x1b,
|
|
0xf5, 0x8e, 0x1e, 0x84, 0x53, 0x3e, 0x39, 0xfe, 0x10, 0xb0, 0xe7, 0x47, 0x11, 0xf2, 0xae, 0xc2,
|
|
0x2a, 0xc3, 0xb5, 0x40, 0xfa, 0xdd, 0xdc, 0x0f, 0xbd, 0x31, 0xba, 0xe3, 0x94, 0x80, 0x36, 0x63,
|
|
0x2d, 0xcf, 0x7b, 0x89, 0x11, 0xa9, 0x79, 0xc5, 0x08, 0x08, 0x95, 0xfc, 0xfa, 0x8d, 0x27, 0xfe,
|
|
0x0b, 0xff, 0x6c, 0xe2, 0xb5, 0x83, 0xd0, 0xf4, 0xce, 0x17, 0xb3, 0x31, 0xbc, 0xfa, 0x3f, 0x9c,
|
|
0x06, 0xaf, 0xb9, 0x9e, 0x2c, 0xfd, 0x27, 0xfd, 0xaf, 0x52, 0xff, 0x9c, 0x7c, 0xfa, 0xc3, 0xa6,
|
|
0xc3, 0x1e, 0x2b, 0xc0, 0x64, 0xe0, 0x35, 0xfe, 0x5c, 0x25, 0x07, 0xa2, 0x4f, 0x37, 0x16, 0xf1,
|
|
0x28, 0x98, 0x7a, 0xec, 0x25, 0xd2, 0xd6, 0x3d, 0x11, 0x81, 0xf4, 0x5f, 0xce, 0x82, 0x57, 0x33,
|
|
0x78, 0x10, 0x69, 0xba, 0xae, 0x34, 0xdd, 0xf1, 0x89, 0x3f, 0xc2, 0x34, 0xb5, 0x9c, 0x67, 0x56,
|
|
0xf4, 0x2d, 0x78, 0x2a, 0x05, 0x6c, 0xd5, 0xbf, 0x24, 0xff, 0xbb, 0x0e, 0xd0, 0x83, 0xd8, 0x62,
|
|
0x7f, 0xbb, 0x1b, 0x63, 0xb2, 0x0b, 0x42, 0xdd, 0x8b, 0x5f, 0x05, 0xe1, 0x4b, 0x0c, 0xc4, 0x63,
|
|
0xf1, 0x97, 0x34, 0xe9, 0xc7, 0xac, 0x99, 0xdc, 0xbc, 0x48, 0x7c, 0xd5, 0x94, 0x64, 0xf6, 0xf7,
|
|
0x83, 0xcd, 0x28, 0x31, 0x80, 0x28, 0xa1, 0x1b, 0x5d, 0x48, 0xcd, 0xe4, 0x7d, 0x37, 0x40, 0x75,
|
|
0x4f, 0x8c, 0x2a, 0x21, 0x2b, 0x73, 0x4a, 0x52, 0xad, 0x36, 0x60, 0x15, 0xf6, 0x27, 0xc3, 0x09,
|
|
0x70, 0xad, 0xe6, 0x76, 0xb7, 0xf2, 0xb3, 0xca, 0x8d, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x5e,
|
|
0xbc, 0x3d, 0xb7, 0xa8, 0x1e, 0x00, 0x00,
|
|
}
|